Merge remote-tracking branch 'adambard/master'

Conflicts:
	swift.html.markdown

7 files changed, 2318 insertions, 19 deletions

diff --git a/tr-tr/brainfuck-tr.html.markdown b/tr-tr/brainfuck-tr.html.markdown
index baca4217..bd842b17 100644
--- a/tr-tr/brainfuck-tr.html.markdown
+++ b/tr-tr/brainfuck-tr.html.markdown
@@ -19,7 +19,7 @@ gözardı edilir.
 Brainfuck 30,000 hücresi olan ve ilk değerleri sıfır olarak atanmış bir
 dizidir. İşaretçi ilk hücreyi işaret eder.
 
-Sekik komut vardır:
+Sekiz komut vardır:
 + : Geçerli hücrenin değerini bir artırır.
 - : Geçerli hücrenin değerini bir azaltır.
 > : Veri işaretçisini bir sonraki hücreye hareket ettirir(sağdaki hücreye).
diff --git a/tr-tr/c-tr.html.markdown b/tr-tr/c-tr.html.markdown
index 128901de..2d4240ed 100644
--- a/tr-tr/c-tr.html.markdown
+++ b/tr-tr/c-tr.html.markdown
@@ -91,9 +91,9 @@ int main() {
     // Örneğin,
     printf("%lu\n", sizeof(int)); // => 4 (bir çok makinede 4-byte words)
 
-    // If the argument of the `sizeof` operator an expression, then its argument
-    // is not evaluated (except VLAs (see below)).
-    // The value it yields in this case is a compile-time constant.
+    // Eger arguman düzenli ifae olan sizeof operatoru ise degerlendirilmez.
+    // VLAs hariç asagiya bakiniz).
+    // Bu durumda verimliligin degeri derleme-zamani sabitidir.
     int a = 1;
 
     // size_t bir objeyi temsil etmek için kullanılan 2 byte uzunluğundaki bir 
@@ -101,7 +101,7 @@ int main() {
 
     size_t size = sizeof(a++); // a++ is not evaluated
     printf("sizeof(a++) = %zu where a = %d\n", size, a);
-    // prints "sizeof(a++) = 4 where a = 1" (on a 32-bit architecture)
+    // yazdirilan "sizeof(a++) = 4 where a = 1" (32-bit mimaride)
 
     // Diziler somut bir boyut ile oluşturulmalıdır.
     char my_char_array[20]; // Bu dizi 1 * 20 = 20 byte alan kaplar
@@ -119,19 +119,19 @@ int main() {
     my_array[1] = 2;
     printf("%d\n", my_array[1]); // => 2
 
-    // In C99 (and as an optional feature in C11), variable-length arrays (VLAs)
-    // can be declared as well. The size of such an array need not be a compile
-    // time constant:
-    printf("Enter the array size: "); // ask the user for an array size
+    // C99'da (ve C11 istege bagli bir ozellik olarak), deÄŸidken-uzunluklu diziler (VLAs) bildirilebilirler.
+    // Böyle bir dizinin boyuunu derlenmesi gerekmez
+    // zaman sabiti:
+    printf("Enter the array size: "); // dizi boyutu kullaniciya soruluyor
     char buf[0x100];
     fgets(buf, sizeof buf, stdin);
 
-    // strtoul parses a string to an unsigned integer
+    // strtoul isaretsiz integerlar icin string ayiricisidir.
     size_t size = strtoul(buf, NULL, 10);
     int var_length_array[size]; // declare the VLA
     printf("sizeof array = %zu\n", sizeof var_length_array);
 
-    // A possible outcome of this program may be:
+    // Bu programın olası bir sonucu olabilir:
     // > Enter the array size: 10
     // > sizeof array = 40
 
@@ -151,8 +151,8 @@ int main() {
     printf("%d\n", a_string[16]); // => 0
     // i.e., byte #17 is 0 (as are 18, 19, and 20)
 
-    // If we have characters between single quotes, that's a character literal.
-    // It's of type `int`, and *not* `char` (for historical reasons).
+    // Tek tirnak arasinda karakterlere sahipsek, bu karakterler degismezdir.
+    // Tip `int` ise, `char` *degildir* (tarihsel sebeplerle).
     int cha = 'a'; // fine
     char chb = 'a'; // fine too (implicit conversion from int to char)
 
@@ -201,10 +201,10 @@ int main() {
     0x01 << 1; // => 0x02 (bitwise left shift (by 1))
     0x02 >> 1; // => 0x01 (bitwise right shift (by 1))
 
-    // Be careful when shifting signed integers - the following are undefined:
-    // - shifting into the sign bit of a signed integer (int a = 1 << 32)
-    // - left-shifting a negative number (int a = -1 << 2)
-    // - shifting by an offset which is >= the width of the type of the LHS:
+    // Isaretli sayilari kaydirirken dikkatli olun - tanimsizlar sunlardir:
+    // - isaretli sayinin isaret bitinde yapÄilan kaydirma (int a = 1 << 32)
+    // - negatif sayilarda sol kaydirma (int a = -1 << 2)
+    // - LHS tipinde >= ile olan ofset genisletmelerde yapilan kaydirma:
     //   int a = 1 << 32; // UB if int is 32 bits wide
 
     ///////////////////////////////////////
@@ -485,4 +485,4 @@ Readable code is better than clever code and fast code. For a good, sane coding
 
 Diğer taraftan google sizin için bir arkadaş olabilir.
 
-[1] http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member
\ No newline at end of file
+[1] http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member
diff --git a/tr-tr/csharp-tr.html.markdown b/tr-tr/csharp-tr.html.markdown
new file mode 100644
index 00000000..91c7c269
--- /dev/null
+++ b/tr-tr/csharp-tr.html.markdown
@@ -0,0 +1,825 @@
+---
+language: c#
+contributors:
+    - ["Irfan Charania", "https://github.com/irfancharania"]
+    - ["Max Yankov", "https://github.com/golergka"]
+    - ["Melvyn Laïly", "http://x2a.yt"]
+    - ["Shaun McCarthy", "http://www.shaunmccarthy.com"]
+translators:
+    - ["Melih Mucuk", "http://melihmucuk.com"]
+lang: tr-tr
+filename: LearnCSharp-tr.cs
+
+---
+
+C# zarif ve tip güvenli nesne yönelimli bir dil olup geliştiricilerin .NET framework üzerinde çalışan güçlü ve güvenli uygulamalar geliştirmesini sağlar.
+
+[Yazım yanlışları ve öneriler için bana ulaşabilirsiniz](mailto:melihmucuk@gmail.com)
+
+[Daha fazlasını okuyun.](http://msdn.microsoft.com/en-us/library/vstudio/z1zx9t92.aspx)
+
+```c#
+// Tek satırlık yorumlar // ile başlar 
+/*
+Birden fazla satırlı yorumlar buna benzer
+*/
+/// <summary>
+/// Bu bir XML dokümantasyon yorumu
+/// </summary>
+
+// Uygulamanın kullanacağı ad alanlarını belirtin
+using System;
+using System.Collections.Generic;
+using System.Data.Entity;
+using System.Dynamic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Net;
+using System.Threading.Tasks;
+using System.IO;
+
+// Kodu düzenlemek için paketler içinde alan tanımlayın
+namespace Learning
+{
+    // Her .cs dosyası, dosya ile aynı isimde en az bir sınıf içermeli
+    // bu kurala uymak zorunda değilsiniz ancak mantıklı olan yol budur.
+    public class LearnCSharp
+    {
+        // TEMEL SÖZ DİZİMİ - daha önce Java ya da C++ kullandıysanız İLGİNÇ ÖZELLİKLER'e geçin
+        public static void Syntax() 
+        {
+            // Satırları yazdırmak için Console.WriteLine kullanın
+            Console.WriteLine("Merhaba Dünya");
+            Console.WriteLine(
+                "Integer: " + 10 +
+                " Double: " + 3.14 +
+                " Boolean: " + true);
+
+            // Yeni satıra geçmeden yazdırmak için Console.Write kullanın
+            Console.Write("Merhaba ");
+            Console.Write("Dünya");
+
+            ///////////////////////////////////////////////////
+            // Tipler & DeÄŸiÅŸkenler
+            //
+            // Bir değişken tanımlamak için <tip> <isim> kullanın
+            ///////////////////////////////////////////////////
+
+            // Sbyte - Signed 8-bit integer
+            // (-128 <= sbyte <= 127)
+            sbyte fooSbyte = 100;
+
+            // Byte - Unsigned 8-bit integer
+            // (0 <= byte <= 255)
+            byte fooByte = 100;
+
+            // Short - 16-bit integer
+            // Signed - (-32,768 <= short <= 32,767)
+            // Unsigned - (0 <= ushort <= 65,535)
+            short fooShort = 10000;
+            ushort fooUshort = 10000;
+
+            // Integer - 32-bit integer
+            int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647)
+            uint fooUint = 1; // (0 <= uint <= 4,294,967,295)
+
+            // Long - 64-bit integer
+            long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+            ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615)
+            // Sayılar boyutlarına göre ön tanımlı olarak int ya da uint olabilir.
+            // L, değişken değerinin long ya da ulong tipinde olduğunu belirtmek için kullanılır.
+
+            // Double - Çift hassasiyetli 64-bit IEEE 754 kayan sayı
+            double fooDouble = 123.4; // Hassasiyet: 15-16 basamak
+
+            // Float - Tek hassasiyetli 32-bit IEEE 754 kayan sayı
+            float fooFloat = 234.5f; // Hassasiyet: 7 basamak
+            // f, değişken değerinin float tipinde olduğunu belirtmek için kullanılır.
+
+            // Decimal - 128-bit veri tiğinde ve diğer kayan sayı veri tiplerinden daha hassastır,
+            // finansal ve mali hesaplamalar için uygundur.
+            decimal fooDecimal = 150.3m;
+
+            // Boolean - true & false
+            bool fooBoolean = true; // veya false
+
+            // Char - 16-bitlik tek bir unicode karakter
+            char fooChar = 'A';
+
+            // Strings -- Önceki baz tiplerinin hepsi değer tipiyken,
+            // string bir referans tipidir. Null deÄŸer atayabilirsiniz
+            string fooString = "\"escape\" quotes and add \n (new lines) and \t (tabs)";
+            Console.WriteLine(fooString);
+
+            // İndeks numarası kullanarak bir string'in bütün karakterlerine erişilebilirsiniz: 
+            char charFromString = fooString[1]; // => 'e'
+            // String'ler değiştirilemez: fooString[1] = 'X' işlemini yapamazsınız;
+
+            // String'leri geçerli kültür değeri ve büyük küçük harf duyarlılığı olmadan karşılaştırma
+            string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase);
+
+            // sprintf baz alınarak formatlama
+            string fooFs = string.Format("Check Check, {0} {1}, {0} {1:0.0}", 1, 2);
+
+            // Tarihler & Formatlama
+            DateTime fooDate = DateTime.Now;
+            Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));
+
+            // Bir string'i iki satıra bölmek için @ sembolü kullanabilirsiniz. " işaretinden kaçmak için "" kullanın
+            string bazString = @"Here's some stuff
+on a new line! ""Wow!"", the masses cried";
+
+            // Bir değişkeni değiştirilemez yapmak için const ya da read-only kullanın. 
+            // const değerleri derleme sırasında hesaplanır
+            const int HOURS_I_WORK_PER_WEEK = 9001;
+
+            ///////////////////////////////////////////////////
+            // Veri Yapıları
+            ///////////////////////////////////////////////////
+
+            // Diziler - Sıfır indeksli
+            // Dizi boyutuna tanımlama sırasında karar verilmelidir.
+            // Dizi tanımlama formatı şöyledir:
+            // <veri tipi>[] <deÄŸiÅŸken ismi> = new <veri tipi>[<dizi boyutu>];
+            int[] intArray = new int[10];
+
+            // Bir diğer dizi tanımlama formatı şöyledir:
+            int[] y = { 9000, 1000, 1337 };
+
+            // Bir diziyi indeksleme - Bir elemente eriÅŸme
+            Console.WriteLine("intArray @ 0: " + intArray[0]);
+            // Diziler deÄŸiÅŸtirilebilir.
+            intArray[1] = 1;
+
+            // Listeler
+            // Listeler daha esnek oldukları için dizilerden daha sık kullanılırlar.
+            // Bir liste tanımlama formatı şöyledir:
+            // List<veri tipi> <deÄŸiÅŸken ismi> = new List<veri tipi>();
+            List<int> intList = new List<int>();
+            List<string> stringList = new List<string>();
+            List<int> z = new List<int> { 9000, 1000, 1337 }; // tanımlama
+            // <> işareti generic ifadeler içindir - Güzel özellikler sekmesini inceleyin
+
+            // Listelerin varsayılan bir değeri yoktur;
+            // İndekse erişmeden önce değer eklenmiş olmalıdır
+            intList.Add(1);
+            Console.WriteLine("intList @ 0: " + intList[0]);
+
+            // Diğer veri yapıları için şunlara bakın:
+            // Stack/Queue (Yığın/Kuyruk)
+            // Dictionary (hash map'in uygulanması) (Sözlük)
+            // HashSet (karma seti)
+            // Read-only Collections (DeÄŸiÅŸtirilemez koleksiyonlar)
+            // Tuple (.Net 4+) (tüp)
+
+            ///////////////////////////////////////
+            // Operatörler
+            ///////////////////////////////////////
+            Console.WriteLine("\n->Operators");
+
+            int i1 = 1, i2 = 2; // Birden çok tanımlamanın kısa yolu
+
+            // Aritmetik basittir
+            Console.WriteLine(i1 + i2 - i1 * 3 / 7); // => 3
+
+            // Mod
+            Console.WriteLine("11%3 = " + (11 % 3)); // => 2
+
+            // Karşılaştırma operatörleri
+            Console.WriteLine("3 == 2? " + (3 == 2)); // => false
+            Console.WriteLine("3 != 2? " + (3 != 2)); // => true
+            Console.WriteLine("3 > 2? " + (3 > 2)); // => true
+            Console.WriteLine("3 < 2? " + (3 < 2)); // => false
+            Console.WriteLine("2 <= 2? " + (2 <= 2)); // => true
+            Console.WriteLine("2 >= 2? " + (2 >= 2)); // => true
+
+            // Bit düzeyi operatörleri!
+            /*
+            ~       Tekli bit tamamlayıcısı
+            <<      Sola kaydırma Signed left shift
+            >>      Sağa kaydırma Signed right shift
+            &       Bit düzeyi AND
+            ^       Bit düzeyi harici OR
+            |       Bit düzeyi kapsayan OR
+            */
+
+            // Arttırma
+            int i = 0;
+            Console.WriteLine("\n->Inc/Dec-rementation");
+            Console.WriteLine(i++); //i = 1. Post-Incrementation
+            Console.WriteLine(++i); //i = 2. Pre-Incrementation
+            Console.WriteLine(i--); //i = 1. Post-Decrementation
+            Console.WriteLine(--i); //i = 0. Pre-Decrementation
+
+            ///////////////////////////////////////
+            // Kontrol Yapıları
+            ///////////////////////////////////////
+            Console.WriteLine("\n->Control Structures");
+
+            // If ifadesi c benzeridir
+            int j = 10;
+            if (j == 10)
+            {
+                Console.WriteLine("I get printed");
+            }
+            else if (j > 10)
+            {
+                Console.WriteLine("I don't");
+            }
+            else
+            {
+                Console.WriteLine("I also don't");
+            }
+
+            // Üçlü operatörler
+            // Basit bir if/else ifadesi şöyle yazılabilir
+            // <koÅŸul> ? <true> : <false>
+            int toCompare = 17;
+            string isTrue = toCompare == 17 ? "True" : "False";
+
+            // While döngüsü
+            int fooWhile = 0;
+            while (fooWhile < 100)
+            {
+                //100 kere tekrarlanır, fooWhile 0->99
+                fooWhile++;
+            }
+
+            // Do While Döngüsü
+            int fooDoWhile = 0;
+            do
+            {
+                //100 kere tekrarlanır, fooDoWhile 0->99
+                fooDoWhile++;
+            } while (fooDoWhile < 100);
+
+            //for döngüsü yapısı => for(<başlangıç ifadesi>; <koşul>; <adım>)
+            for (int fooFor = 0; fooFor < 10; fooFor++)
+            {
+                //10 kere tekrarlanır, fooFor 0->9
+            }
+
+            // For Each Döngüsü
+            // foreach döngüsü yapısı => foreach(<yineleyici tipi> <yineleyici ismi> in <enumerable>)
+            // foreach döngüsü, IEnumerable ya da IEnumerable<T> e dönüştürülmüş herhangi bir obje üzerinde döngü yapabilir
+            // .Net framework üzerindeki bütün koleksiyon tiplerinden (Dizi, Liste, Sözlük...)
+            // biri ya da hepsi uygulanarak gerçekleştirilebilir.
+            // (ToCharArray() silindi, çünkü string'ler aynı zamanda IEnumerable'dır.)
+            foreach (char character in "Hello World".ToCharArray())
+            {
+                //String içindeki bütün karakterler üzerinde döner
+            }
+
+            // Switch Case
+            // Bir switch byte, short, char ve int veri tipleri ile çalışır.
+            // Aynı zamanda sıralı tipler ile de çalışabilir.(Enum Tipleri bölümünde tartışıldı),
+            // String sınıfı, ve bir kaç özel sınıf kaydırılır
+            // basit tipler: Character, Byte, Short, and Integer.
+            int month = 3;
+            string monthString;
+            switch (month)
+            {
+                case 1:
+                    monthString = "January";
+                    break;
+                case 2:
+                    monthString = "February";
+                    break;
+                case 3:
+                    monthString = "March";
+                    break;
+                // Bir aksiyon için birden fazla durum atayabilirsiniz
+                // Ancak, break olmadan yeni bir durum ekleyemezsiniz
+                // (Eğer bunu yapmak istiyorsanız, goto komutu eklemek zorundasınız)
+                case 6:
+                case 7:
+                case 8:
+                    monthString = "Summer time!!";
+                    break;
+                default:
+                    monthString = "Some other month";
+                    break;
+            }
+
+            ///////////////////////////////////////
+            // Veri Tipleri Dönüştürme ve Typecasting
+            ///////////////////////////////////////
+
+            // Veri Dönüştürme
+
+            // String'i Integer'a Dönüştürme
+            // bu başarısız olursa hata fırlatacaktır
+            int.Parse("123");// "123" 'in Integer değerini döndürür
+
+            // try parse hata durumunda değişkene varsayılan bir değer atamak için kullanılır
+            // bu durumda: 0
+            int tryInt;
+            if (int.TryParse("123", out tryInt)) // Fonksiyon boolean'dır
+                Console.WriteLine(tryInt);       // 123
+
+            // Integer'ı String'e Dönüştürme
+            // Convert sınıfı dönüştürme işlemini kolaylaştırmak için bir dizi metoda sahiptir
+            Convert.ToString(123);
+            // veya
+            tryInt.ToString();
+        }
+
+        ///////////////////////////////////////
+        // SINIFLAR - dosyanın sonunda tanımları görebilirsiniz
+        ///////////////////////////////////////
+        public static void Classes()
+        {
+            // Obje tanımlamalarını dosyanın sonunda görebilirsiniz
+
+            // Bir sınıfı türetmek için new kullanın
+            Bicycle trek = new Bicycle();
+
+            // Obje metodlarını çağırma
+            trek.SpeedUp(3); // Her zaman setter ve getter metodları kullanmalısınız
+            trek.Cadence = 100;
+
+            // ToString objenin değerini göstermek için kullanılır.
+            Console.WriteLine("trek info: " + trek.Info());
+
+            // Yeni bir Penny Farthing sınıfı türetmek
+            PennyFarthing funbike = new PennyFarthing(1, 10);
+            Console.WriteLine("funbike info: " + funbike.Info());
+
+            Console.Read();
+        } // Ana metodun sonu
+
+        // KONSOLE BAŞLANGICI Bir konsol uygulaması başlangıç olarak mutlaka ana metod'a sahip olmalı
+        public static void Main(string[] args)
+        {
+            OtherInterestingFeatures();
+        }
+
+        //
+        // İLGİNÇ ÖZELLİKLER
+        //
+        
+        // VARSAYILAN METOD TANIMLAMALARI
+
+        public // Görünebilir
+        static // Sınıf üzerinden obje türetmeden çağırılabilir
+        int // Dönüş Tipi,
+        MethodSignatures(
+            int maxCount, // Ä°lk deÄŸiÅŸken, int deÄŸer bekler
+            int count = 0, // Eğer değer gönderilmezse varsayılan olarak 0 değerini alır
+            int another = 3,
+            params string[] otherParams // Metoda gönderilen diğer bütün parametreleri alır
+        )
+        { 
+            return -1;
+        }
+
+        // Metodlar tanımlamalar benzersiz ise aynı isimleri alabilirler
+        public static void MethodSignatures(string maxCount)
+        {
+        }
+
+        // GENERIC'LER
+        // TKey ve TValue değerleri kullanıcı tarafından bu fonksiyon çağırılırken belirtilir.
+        // Bu metod Python'daki SetDefault'a benzer
+        public static TValue SetDefault<TKey, TValue>(
+            IDictionary<TKey, TValue> dictionary, 
+            TKey key, 
+            TValue defaultItem)
+        {
+            TValue result;
+            if (!dictionary.TryGetValue(key, out result))
+                return dictionary[key] = defaultItem;
+            return result;
+        }
+
+        // Gönderilen objeleri daraltabilirsiniz
+        public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>
+        {
+            // EÄŸer T IEnumerable ise tekrarlayabiliriz
+            foreach (var item in toPrint)
+                // Item bir int
+                Console.WriteLine(item.ToString());
+        }
+
+        public static void OtherInterestingFeatures()
+        {
+            // Ä°STEÄžE BAÄžLI PARAMETRELER
+            MethodSignatures(3, 1, 3, "Some", "Extra", "Strings");
+            MethodSignatures(3, another: 3); // isteğe bağlı olanlar gönderilmedi
+
+            // UZANTI METODLARI
+            int i = 3;
+            i.Print(); // Aşağıda tanımlandı
+
+            // NULLABLE TYPES - veri tabanı işlemleri için uygun / return values
+            // Herhangi bir değer tipi sonuna ? eklenerek nullable yapılabilir (sınıflar hariç)
+            // <tip>? <deÄŸiken ismi> = <deÄŸer>
+            int? nullable = null; // Nullable<int> için kısa yol
+            Console.WriteLine("Nullable variable: " + nullable);
+            bool hasValue = nullable.HasValue; // eğer null değilse true döner
+
+            // ?? varsayılan değer belirlemek için söz dizimsel güzel bir özellik
+            // bu durumda değişken null'dır
+            int notNullable = nullable ?? 0; // 0
+
+            // TİPİ BELİRTİLMEMİŞ DEĞİŞKENLER - compiler değişkenin tipini bilmeden çalışabilir:
+            var magic = "magic is a string, at compile time, so you still get type safety";
+            // magic = 9; string gibi çalışmayacaktır, bu bir int değil
+
+            // GENERIC'LER
+            //
+            var phonebook = new Dictionary<string, string>() { 
+                {"Sarah", "212 555 5555"} // Telefon rehberine bir kaç numara ekleyelim.
+            };
+
+            // Yukarıda generic olarak tanımlanan SETDEFAULT'u çağırma
+            Console.WriteLine(SetDefault<string,string>(phonebook, "Shaun", "No Phone")); // Telefonu yok
+            // TKey ve TValue tipini belirtmek zorunda deÄŸilsiniz
+            Console.WriteLine(SetDefault(phonebook, "Sarah", "No Phone")); // 212 555 5555
+
+            // LAMBDA IFADELERİ - satır içinde kod yazmanıza olanak sağlar
+            Func<int, int> square = (x) => x * x; // Son T nesnesi dönüş değeridir
+            Console.WriteLine(square(3)); // 9
+
+            // TEK KULLANIMLIK KAYNAK YÖNETİMİ -  Yönetilemeyen kaynakların üstesinden kolayca gelebilirsiniz.
+            // Bir çok obje yönetilemeyen kaynaklara (dosya yakalama, cihaz içeriği, vb.)
+            // IDisposable arabirimi ile erişebilir. Using ifadesi sizin için IDisposable objeleri temizler.
+            using (StreamWriter writer = new StreamWriter("log.txt"))
+            {
+                writer.WriteLine("Nothing suspicious here");
+                // Bu bölümün sonunda kaynaklar temilenir.
+                // Hata fırlatılmış olsa bile.
+            } 
+
+            // PARALEL FRAMEWORK
+            // http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx
+            var websites = new string[] { 
+                "http://www.google.com", "http://www.reddit.com", 
+                "http://www.shaunmccarthy.com"
+            };
+            var responses = new Dictionary<string, string>();
+            
+            // Her istek farklı bir thread de işlem görecek 
+            // bir sonraki işleme geçmeden birleştirilecek.
+            Parallel.ForEach(websites, 
+                new ParallelOptions() {MaxDegreeOfParallelism = 3}, // en fazla 3 thread kullanmak için
+                website =>
+            {
+                // Uzun sürecek bir işlem yapın
+                using (var r = WebRequest.Create(new Uri(website)).GetResponse())
+                {
+                    responses[website] = r.ContentType;
+                }
+            });
+
+            // Bütün istekler tamamlanmadan bu döndü çalışmayacaktır.
+            foreach (var key in responses.Keys)
+                Console.WriteLine("{0}:{1}", key, responses[key]);
+
+            // DİNAMİK OBJELER (diğer dillerle çalışırken kullanmak için uygun)
+            dynamic student = new ExpandoObject();
+            student.FirstName = "First Name"; // Önce yeni bir sınıf tanımlamanız gerekmez!
+
+            // Hatta metod bile ekleyebilirsiniz (bir string döner, ve bir string alır)
+            student.Introduce = new Func<string, string>(
+                (introduceTo) => string.Format("Hey {0}, this is {1}", student.FirstName, introduceTo));
+            Console.WriteLine(student.Introduce("Beth"));
+
+            // IQUERYABLE<T> - neredeyse bütün koleksiyonlar bundan türer, bu size bir çok
+            // kullanışlı Map / Filter / Reduce stili metod sağlar.
+            var bikes = new List<Bicycle>();
+            bikes.Sort(); // Dizi sıralama
+            bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels)); // Wheels baz alınarak sıralama
+            var result = bikes
+                .Where(b => b.Wheels > 3) // Filters- chainable (bir önceki tipin IQueryable'ını döner)
+                .Where(b => b.IsBroken && b.HasTassles)
+                .Select(b => b.ToString()); // Map - sadece bunu seçiyoruz, yani sonuç bir IQueryable<string> olacak
+
+            var sum = bikes.Sum(b => b.Wheels); // Reduce - koleksiyonda bulunan bütün wheel değerlerinin toplamı
+
+            // Bike içindeki bazı parametreleri baz alarak bir liste oluşturmak
+            var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles });
+            // Burada göstermek zor ama, compiler yukaridaki tipleri çözümleyebilirse derlenmeden önce tipi verebilir.
+            foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome))
+                Console.WriteLine(bikeSummary.Name);
+
+            // ASPARALLEL
+            // Linq ve paralel iÅŸlemlerini birleÅŸtirme
+            var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name);
+            // bu paralel bir şekilde gerçekleşecek! Threadler otomatik ve sihirli bir şekilde işleri paylaşacak! 
+            // Birden fazla çekirdeğiniz varsa büyük veri setleri ile kullanmak için oldukça uygun bir yapı.
+
+            // LINQ - IQueryable<T> objelerini mapler ve saklar, gecikmeli bir iÅŸlemdir
+            // e.g. LinqToSql - veri tabanını mapler, LinqToXml xml dökümanlarını mapler.
+            var db = new BikeRepository();
+
+            // işlem gecikmelidir, bir veri tabanı üzerinde sorgulama yaparken harikadır.
+            var filter = db.Bikes.Where(b => b.HasTassles); // sorgu henüz çalışmadı
+            if (42 > 6) // Filtreler eklemeye devam edebilirsiniz - ileri düzey arama fonksiyonları için harikadır
+                filter = filter.Where(b => b.IsBroken); // sorgu henüz çalışmadı
+
+            var query = filter
+                .OrderBy(b => b.Wheels)
+                .ThenBy(b => b.Name)
+                .Select(b => b.Name); // hala sorgu çalışmadı
+
+            // Şimdi sorgu çalışıyor, reader'ı açar ama sadece sizin sorgunuza uyanlar foreach döngüsüne girer.
+            foreach (string bike in query) 
+                Console.WriteLine(result);
+            
+
+
+        }
+
+    } // LearnCSharp sınıfının sonu
+
+    // Bir .cs dosyasına diğer sınıflarıda dahil edebilirsiniz
+
+    public static class Extensions
+    {
+        // UZANTI FONKSÄ°YONLARI
+        public static void Print(this object obj)
+        {
+            Console.WriteLine(obj.ToString());
+        }
+    }
+
+    // Sınıf Tanımlama Sözdizimi:
+    // <public/private/protected/internal> class <sınıf ismi>{
+    //    //veri alanları, kurucular , fonksiyonlar hepsi içindedir.
+    //    //Fonksiyonlar Java'daki gibi metod olarak çağırılır.
+    // }
+
+    public class Bicycle
+    {
+        // Bicycle'ın Alanları/Değişkenleri
+        public int Cadence // Public: herhangi bir yerden eriÅŸilebilir
+        {
+            get // get - değeri almak için tanımlanan metod
+            {
+                return _cadence;
+            }
+            set // set - değer atamak için tanımlanan metod
+            {
+                _cadence = value; // Değer setter'a gönderilen value değeridir
+            }
+        }
+        private int _cadence;
+
+        protected virtual int Gear // Protected: Sınıf ve alt sınıflar tarafından erişilebilir
+        {
+            get; // bir üye alanına ihtiyacınız yok, bu otomatik olarak bir değer oluşturacaktır
+            set;
+        }
+
+        internal int Wheels // Internal: Assembly tarafından erişilebilir
+        {
+            get;
+            private set; // Nitelik belirleyicileri get/set metodlarında atayabilirsiniz
+        }
+
+        int _speed; // Her şey varsayılan olarak private'dır : Sadece sınıf içinden erişilebilir.
+                    // Ä°sterseniz yinede private kelimesini kullanabilirsiniz.
+        public string Name { get; set; }
+
+        // Enum sabitler kümesinden oluşan bir değer tipidir.
+        // Gerçekten sadece bir isim ile bir değeri tutmak için kullanılır. (aksi belirtilmedikçe bir int'dir).
+        // İzin verilen enum tipleri şunlardır byte, sbyte, short, ushort, int, uint, long, veya ulong.
+        // Bir enum aynı değeri birden fazla sayıda barındıramaz.
+        public enum BikeBrand
+        {
+            AIST,
+            BMC,
+            Electra = 42, // bir isme tam bir deÄŸer verebilirsiniz
+            Gitane // 43
+        }
+        // Bu tipi Bicycle sınıfı içinde tanımladığımız için bu bir bağımlı tipdir.
+        // Bu sınıf dışında kullanmak için tipi Bicycle.Brand olarak kullanmamız gerekir
+
+        public BikeBrand Brand; // Enum tipini tanımladıktan sonra alan tipini tanımlayabiliriz
+
+        // Static üyeler belirli bir obje yerine kendi tipine aittir
+        // Onlara bir obje referans göstermeden erişebilirsiniz:
+        // Console.WriteLine("Bicycles created: " + Bicycle.bicyclesCreated);
+        static public int BicyclesCreated = 0;
+
+        // readonly değerleri çalışma zamanında atanır
+        // onlara sadece tanımlama yapılarak ya da kurucular içinden atama yapılabilir
+        readonly bool _hasCardsInSpokes = false; // read-only private
+
+        // Kurucular sınıf oluşturmanın bir yoludur
+        // Bu bir varsayılan kurucudur.
+        public Bicycle() 
+        {
+            this.Gear = 1; // bu objenin üyelerine this anahtar kelimesi ile ulaşılır
+            Cadence = 50;  // ama her zaman buna ihtiyaç duyulmaz
+            _speed = 5;
+            Name = "Bontrager";
+            Brand = BikeBrand.AIST;
+            BicyclesCreated++;
+        }
+
+        // Bu belirlenmiş bir kurucudur. (argümanlar içerir)
+        public Bicycle(int startCadence, int startSpeed, int startGear,
+                       string name, bool hasCardsInSpokes, BikeBrand brand) 
+            : base() // önce base'i çağırın
+        {
+            Gear = startGear; 
+            Cadence = startCadence;
+            _speed = startSpeed;
+            Name = name; 
+            _hasCardsInSpokes = hasCardsInSpokes;
+            Brand = brand;
+        }
+
+        // Kurucular zincirleme olabilir
+        public Bicycle(int startCadence, int startSpeed, BikeBrand brand) :
+            this(startCadence, startSpeed, 0, "big wheels", true, brand)
+        {
+        }
+
+        // Fonksiyon Sözdizimi:
+        // <public/private/protected> <dönüş tipi> <fonksiyon ismi>(<argümanlar>)
+
+        // sınıflar getter ve setter'ları alanları için kendisi uygular
+        // veya property'ler eklenebilir (C# da tercih edilen yol budur)
+
+        // Metod parametreleri varsayılan değerlere sahip olabilir.
+        // Bu durumda, metodlar bu parametreler olmadan çağırılabilir.
+        public void SpeedUp(int increment = 1)
+        {
+            _speed += increment;
+        }
+
+        public void SlowDown(int decrement = 1)
+        {
+            _speed -= decrement;
+        }
+
+        // property'lerin get/set deÄŸerleri
+        // sadece veri gerektiği zaman erişilebilir, kullanmak için bunu göz önünde bulundurun.
+        // property'ler sadece get ya da set'e sahip olabilir veya ikisine birden
+        private bool _hasTassles; // private deÄŸiÅŸken
+        public bool HasTassles // public accessor
+        {
+            get { return _hasTassles; }
+            set { _hasTassles = value; }
+        }
+
+        // Ayrıca tek bir satırda otomatik property tanımlayabilirsiniz. 
+        // bu söz dizimi otomatik olarak alan oluşturacaktır.
+        // Erişimi kısıtlamak için nitelik belirleyiciler getter veya setter'a ya da ikisine birden atanabilir:
+        public bool IsBroken { get; private set; }
+
+        // Property'ler otomatik eklenmiÅŸ olabilir
+        public int FrameSize
+        {
+            get;
+            // nitelik beliryecileri get veya set için tanımlayabilirsiniz
+            // bu sadece Bicycle sınıfı Framesize değerine atama yapabilir demektir
+            private set;
+        }
+
+        // Ayrıca obje üzerinde özel indeksleyici belirlemek mümkündür.
+        // Tüm bunlar bu örnek için çok kullanışlı değil,
+        // bicycle[0] ile ilk yolcu olan "chris" i almak mümkün veya
+        // bicycle[1] = "lisa" ile yolcuyu atayabilirsiniz. (bariz quattrocycle)
+        private string[] passengers = { "chris", "phil", "darren", "regina" }
+
+        public string this[int i]
+        {
+            get {
+                return passengers[i];
+            }
+
+            set {
+                return passengers[i] = value;
+            }
+        }
+
+        //Bu objenin nitelik değerlerini göstermek için bir metod.
+        public virtual string Info()
+        {
+            return "Gear: " + Gear +
+                    " Cadence: " + Cadence +
+                    " Speed: " + _speed +
+                    " Name: " + Name +
+                    " Cards in Spokes: " + (_hasCardsInSpokes ? "yes" : "no") +
+                    "\n------------------------------\n"
+                    ;
+        }
+
+        // Metodlar static olabilir. Yardımcı metodlar için kullanışlı olabilir.
+        public static bool DidWeCreateEnoughBycles()
+        {
+            // Bir static metod içinde sadece static sınıf üyeleri referans gösterilebilir
+            return BicyclesCreated > 9000;
+        } // Eğer sınıfınızın sadece static üyelere ihtiyacı varsa, sınıfın kendisini static yapmayı düşünebilirsiniz.
+
+
+    } // Bicycle sınıfı sonu
+
+    // PennyFarthing , Bicycle sınıfının alt sınıfıdır.
+    class PennyFarthing : Bicycle
+    {
+        // (Penny Farthing'ler ön jantı büyük bisikletlerdir.
+        // Vitesleri yoktur.)
+
+        // Ana kurucuyu çağırmak
+        public PennyFarthing(int startCadence, int startSpeed) :
+            base(startCadence, startSpeed, 0, "PennyFarthing", true, BikeBrand.Electra)
+        {
+        }
+
+        protected override int Gear
+        {
+            get
+            {
+                return 0;
+            }
+            set
+            {
+                throw new ArgumentException("You can't change gears on a PennyFarthing");
+            }
+        }
+
+        public override string Info()
+        {
+            string result = "PennyFarthing bicycle ";
+            result += base.ToString(); // Metodun temel versiyonunu çağırmak
+            return result;
+        }
+    }
+
+    // Arabirimler sadece üyelerin izlerini içerir, değerlerini değil.
+    interface IJumpable
+    {
+        void Jump(int meters); // bütün arbirim üyeleri public'tir
+    }
+
+    interface IBreakable
+    {
+        bool Broken { get; } // arabirimler property'leri, metodları ve olayları içerebilir
+    }
+
+    // Sınıflar sadece tek bir sınıftan miras alabilir ama sınırsız sayıda arabirime sahip olabilir
+    class MountainBike : Bicycle, IJumpable, IBreakable
+    {
+        int damage = 0;
+
+        public void Jump(int meters)
+        {
+            damage += meters;
+        }
+
+        public bool Broken
+        {
+            get
+            {
+                return damage > 100;
+            }
+        }
+    }
+
+    /// <summary>
+    /// LinqToSql örneği veri tabanına bağlanmak için kullanılır.
+    /// EntityFramework Code First harika! (Ruby'deki ActiveRecord'a benzer, ama iki yönlü)
+    /// http://msdn.microsoft.com/en-us/data/jj193542.aspx
+    /// </summary>
+    public class BikeRepository : DbSet
+    {
+        public BikeRepository()
+            : base()
+        {
+        }
+
+        public DbSet<Bicycle> Bikes { get; set; }
+    }
+} // namespace sonu
+```
+
+## Ä°ÅŸlenmeyen Konular
+
+ * Flags
+ * Attributes
+ * Static properties
+ * Exceptions, Abstraction
+ * ASP.NET (Web Forms/MVC/WebMatrix)
+ * Winforms
+ * Windows Presentation Foundation (WPF)
+
+## Daha Fazlasını Okuyun
+
+ * [DotNetPerls](http://www.dotnetperls.com)
+ * [C# in Depth](http://manning.com/skeet2)
+ * [Programming C#](http://shop.oreilly.com/product/0636920024064.do)
+ * [LINQ](http://shop.oreilly.com/product/9780596519254.do)
+ * [MSDN Library](http://msdn.microsoft.com/en-us/library/618ayhy6.aspx)
+ * [ASP.NET MVC Tutorials](http://www.asp.net/mvc/tutorials)
+ * [ASP.NET Web Matrix Tutorials](http://www.asp.net/web-pages/tutorials)
+ * [ASP.NET Web Forms Tutorials](http://www.asp.net/web-forms/tutorials)
+ * [Windows Forms Programming in C#](http://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208)
+
+
+
+[C# Kodlama Adetleri](http://msdn.microsoft.com/en-us/library/vstudio/ff926074.aspx)
diff --git a/tr-tr/markdown-tr.html.markdown b/tr-tr/markdown-tr.html.markdown
new file mode 100644
index 00000000..bac8f6fc
--- /dev/null
+++ b/tr-tr/markdown-tr.html.markdown
@@ -0,0 +1,251 @@
+---
+language: markdown
+contributors:
+    - ["Dan Turkel", "http://danturkel.com/"]
+translators:
+    - ["Eray AYDIN", "http://erayaydin.me/"]
+lang: tr-tr
+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
+<!-- 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,
+bu elementin içeriğinde markdown söz dizimlerini kullanamazsınız. -->
+
+<!-- Markdown ayrıca işleyiciden işleyiciye farklılık gösterebilir. Bu rehberde
+evrensel özelliklere uygun anlatımlar olacaktır. Bir çok işleyici bu rehberdeki
+anlatımları destekler -->
+
+<!-- Başlıklar -->
+<!-- Kolayca <h1>'den <h6>'ya HTML etiketleri oluÅŸturabilirsiniz.
+Kare (#) sayısı bu elementin numarasını belirleyecek ve devamında getirdiğiniz
+yazı bu elementin içeriği olacaktır
+-->
+# Bu bir <h1>
+## Bu bir <h2>
+### Bu bir <h3>
+#### Bu bir <h4>
+##### Bu bir <h5>
+###### Bu bir <h6>
+
+<!-- Markdown ayrıca h1 ve h2 için 2 alternatif yol daha taşır -->
+Bu bir h1
+=========
+
+Bu bir h2
+---------
+
+<!-- Basit yazı stilleri -->
+<!-- Markdown ile yazılar kolayca italik ve kalın belirtilebilir -->
+*Bu yazı italik.*
+_Bu yazı da italik._
+
+**Bu yazı kalın.**
+__Bu yazı da kalın.__
+
+***Bu yazı hem kalın hem italik.***
+**_Bu da öyle!_**
+*__Hatta bu bile!__*
+
+<!-- Github Flavored Markdown'da ayrıca üstü çizgili karakter de desteklenir: -->
+~~Bu yazı üstü çizili olarak gözükecek.~~
+
+<!-- Paragraflar bir veya daha fazla boş satırla ayrılır. -->
+
+Bu bir paragraf. Paragrafın içeriğine devam ediyorum, eğlenceli değil mi?
+
+Şimdi 2. paragrafıma geçtim.
+Hala 2. paragraftayım, çünkü boş bir satır bırakmadım.
+
+Bu da 3. paragrafım!
+
+<!-- HTML'de her satır için <br /> etiketi kullanmak ister misiniz, Bir
+paragrafı bitirdikten sonra 2 veya daha fazla boşluk bırakın ve yeni paragrafa
+başlayın, bu bir <br /> etiketi sayılacaktır  -->
+
+Bu yazının sonunda 2 boşluk var (bu satırı seçerek kontrol edebilirsiniz).  
+
+Bir üst satırda <br /> etiketi var!
+
+<!-- Blok yazılarının yapımı oldukça kolay, (>) karakteri ile yapabilirsiniz  -->
+
+> Bu bir blok etiketi. Satırlara ayırmak için
+> her satırın başında `>` karakter yerleştirmeli veya tek satırda bütün içeriği yazabilirsiniz.
+> Satır `>` karakteri ile başladığı sürece sorun yok. 
+
+> Ayrıca alt alta da blok elementi açabilirsiniz
+>> iç içe yani
+> düzgün değil mi ?
+
+<!-- Listeler -->
+<!-- Numarasız listeler için yıldız, artı, veya tire kullanabilirsiniz -->
+
+* Nesne
+* Nesne
+* Bir baÅŸka nesne
+
+veya
+
++ Nesne
++ Nesne
++ Bir baÅŸka nesne
+
+veya
+
+- Nesne
+- Nesne
+- Son bir nesne
+
+<!-- Numaralı liste için başına sıralı bir şekilde sayı eklemeniz yeterli -->
+
+1. Ä°lk nesne
+2. Ä°kinci nesne
+3. Üçüncü nesne
+
+<!-- İsterseniz sıralı bir şekilde yazmak zorunda değilsiniz, markdown
+biçimlendirirken sizin için sıralayacaktır, fakat bunu önermiyorum. Markdown dosyasının
+düzgün gözükmesi için önerilen metodu uygulamanızı tavsiye ederim -->
+
+1. Ä°lk nesne
+1. Ä°kinci nesne
+1. Üçüncü nesne
+
+<!-- (Bunun çıktısı ile, sıralı olarak yazdığımız örneğin çıktısı aynı olacaktır) -->
+
+<!-- Ayrıca alt alta liste oluşturabilirsiniz -->
+
+1. Ä°lk nesne
+2. Ä°kinci nesne
+3. Üçüncü nesne
+    * Alt nesne
+    * Alt nesne
+4. Dördüncü nesne
+
+<!-- Ayrıca görev listeleri de bulunmakta. HTML seçim kutusu(checkbox) oluşturacaktır. -->
+Kutunun içerisinde `x` yoksa eğer seçim kutusu boş olacaktır.
+- [ ] Yapılacak ilk görev.
+- [ ] Yapılması gereken bir başka görev
+Aşağıdaki seçim kutusu ise içi dolu olacaktır.
+- [x] Bu görev başarıyla yapıldı
+
+<!-- Kod blokları -->
+<!-- Kod bloklarını(<code> elementi) belirtmek için 4 adet boşluk veya bir
+tab karakterini kullanabilirsiniz -->
+
+    Bu bir kod
+    öyle mi?
+
+<!-- Ayrıca kod içerisinde girinti kullanmak istiyorsanız tekrar `tab` veya `4 boşluk`
+kullanabilirsiniz -->
+
+    my_array.each do |item|
+        puts item
+    end
+
+<!-- Yazı içerisinde kod belirtmek için sorgu tırnağı (`) kullanabilirsiniz -->
+
+Ahmet `go_to()` fonksiyonun ne yaptığını bilmiyor!
+
+<!-- Github Flavored Markdown'da, kod içerisinde aydınlatma kullanabilirsiniz -->
+
+\`\`\`ruby <!-- buradaki ters slaş (\) işaretlerini kullanmayın, sadece ```ruby ! -->
+def foobar
+    puts "Hello world!"
+end
+\`\`\` <!-- burada da (\) işaretlerini kullanmayın, sadece ``` -->
+
+<!-- Yukarıdaki örnekte girinti kullanmanıza gerek yok, Github da 
+``` işaretinden sonra belirttiğiniz yazılım diline göre gerekli
+syntax aydınlatmaları uygulanacaktır -->
+
+<!-- Düz çizgi (<hr />) -->
+<!-- Düz çizgiler 3 veya daha fazla yıldız/çizgi ile yapılabilir. Boşluklar önemsiz. -->
+
+***
+---
+- - -
+****************
+
+<!-- Linkler -->
+<!-- Markdown'daki en güzel şeylerden biri kolayca link oluşturmaktır. 
+Linkte göstermek istediğiniz yazıyı [] içerisine yerleştirin ve sonuna parantezler içerisinde ()
+gideceÄŸi adresi belirtin -->
+
+[Bana tıkla!](http://test.com)
+
+<!-- Ayrıca linke `title` özelliği eklemek için tırnakları kullanabilirsiniz -->
+
+[Bana tıkla!](http://test.com "Test.com'a gider")
+
+<!-- Bağıl yollar da çalışıyor. -->
+[Müzik dinle](/muzik/).
+
+<!-- Markdown ayrıca referans linklerini de destekler -->
+
+[Bu linke tıklayarak][link1] daha detaylı bilgi alabilirsiniz!
+[Ayrıca bu linki de inceleyin][foobar] tabi istiyorsanız.
+
+[link1]: http://test.com/ "harika!"
+[foobar]: http://foobar.biz/ "okey!"
+
+<!--Başlık ayrıca tek tırnak veya parantez içinde olabilir, veya direk yazılabilir.
+Referans döküman içerisindeki herhangi bir yer olabilir ve referans IDsi 
+benzersiz olduğu sürece sorunsuz çalışacaktır. -->
+
+<!-- Ayrıca "dolaylı adlandırma" bulunmaktadır, "dolaylı adlandırma", linkin yazısının
+aynı zamanda onun idsi olmasıdır -->
+
+[Bu][] bir link.
+[bu]: http://bubirlink.com
+
+<!-- Fakat bu çok tercih edilen bir yöntem değil. -->
+
+<!-- Resimler -->
+<!-- Resimler aslında linklere çok benziyor fakat başında ünlem bulunuyor! -->
+![Bu alt etiketine gelecek içerik](http://imgur.com/resmim.jpg "Bu da isteğe bağlı olan bir başlık")
+
+<!-- Referanslar resimler için de geçerli -->
+![Bu alt etiketi.][resmim]
+
+[resmim]: bagil/linkler/de/calisiyor.jpg "Başlık isterseniz buraya girebilirsiniz"
+
+<!-- Çeşitli -->
+<!-- Oto-linkler -->
+
+<http://testwebsite.com/> ile
+[http://testwebsite.com/](http://testwebsite.com) aynı şeyler
+
+<!-- Oto-linkler epostaları da destekler -->
+
+<foo@bar.com>
+
+<!-- Kaçış karakterleri -->
+
+Bu yazının *yıldızlar arasında gözükmesini* istiyorum fakat italik olmamasını istiyorum,
+bunun için, şu şekilde: \*bu yazı italik değil, yıldızlar arasında\*.
+
+<!-- Tablolar -->
+<!-- Tablolar sadece Github Flavored Markdown'da destekleniyor ve açıkçası
+performansı çok yoruyorlar, fakat illa ki kullanmak isterseniz: -->
+
+| Sütun1       | Sütun 2  | Sütün 3       |
+| :----------- | :------: | ------------: |
+| Sola dayalı  | Ortalı   | Sağa dayalı   |
+| test         | test     | test          |
+
+<!-- ayrıca, bunun aynısı -->
+
+Sütun 1 | Sütun 2 | Sütun 3
+:-- | :-: | --:
+Çok çirkin göözüküyor | değil | mi?
+
+<!-- BitiÅŸ! -->
+
+```
+
+Daha detaylı bilgi için, John Gruber'in resmi söz dizimi yazısını [buradan](http://daringfireball.net/projects/markdown/syntax) veya Adam Pritchard'ın mükemmel hatırlatma kağıdını [buradan](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) inceleyebilirsiniz.
diff --git a/tr-tr/objective-c-tr.html.markdown b/tr-tr/objective-c-tr.html.markdown
index f27cbf08..727f973e 100644
--- a/tr-tr/objective-c-tr.html.markdown
+++ b/tr-tr/objective-c-tr.html.markdown
@@ -14,7 +14,7 @@ kendi çatıları olan Cocoa ve Cocoa Touch için kullanılan bir programlama di
 Genel açamlı, object-oriented bir yapıya sahip programlama dilidir. C 
 programlama diline Smalltalk stilinde mesajlaÅŸma ekler.  
 
-```objective_c
+```objective-c
 // Tek satır yorum // işaretleri ile başlar
 
 /*
diff --git a/tr-tr/python3-tr.html.markdown b/tr-tr/python3-tr.html.markdown
new file mode 100644
index 00000000..2477c5da
--- /dev/null
+++ b/tr-tr/python3-tr.html.markdown
@@ -0,0 +1,635 @@
+---
+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
+
+# 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
+
+* [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)
+
+### 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/swift-tr.html.markdown b/tr-tr/swift-tr.html.markdown
new file mode 100644
index 00000000..c13f5ecf
--- /dev/null
+++ b/tr-tr/swift-tr.html.markdown
@@ -0,0 +1,588 @@
+---
+language: swift
+contributors:
+  - ["Özgür Şahin", "https://github.com/ozgurshn/"]
+filename: learnswift.swift
+lang: tr-tr
+---
+
+Swift iOS ve OSX platformlarında geliştirme yapmak için Apple tarafından oluşturulan yeni bir programlama dilidir.  Objective - C ile beraber kullanılabilecek ve de hatalı kodlara karşı daha esnek bir yapı sunacak bir şekilde tasarlanmıştır. Swift 2014 yılında Apple'ın geliştirici konferansı WWDC de tanıtıldı. Xcode 6+'a dahil edilen LLVM derleyici ile geliştirildi.
+ 
+
+Apple'ın resmi [Swift Programlama Dili](https://itunes.apple.com/us/book/swift-programming-language/id881256329) kitabı iBooks'ta yerini aldı.
+
+Ayrıca Swift ile gelen tüm özellikleri görmek için Apple'ın [başlangıç kılavuzu](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/RoadMapiOS/index.html)na bakmanızda yarar var.
+
+
+
+```swift
+// modülü import etme
+import UIKit
+
+//
+// MARK: Temeller
+//
+
+
+//XCode işaretlemelerle kodunuzu bölümlere ayırmanızı ve sağ üstteki metot
+ listesinde gruplama yapmanıza olanak sağlıyor
+// MARK: Bölüm işareti
+// TODO: Daha sonra yapılacak
+// FIXME: Bu kodu düzelt
+
+ 
+//Swift 2 de, println ve print metotları print komutunda birleştirildi. Print
+ otomatik olarak yeni satır ekliyor.  
+print("Merhaba dünya") // println print olarak kullanılıyor.
+print("Merhaba dünya", appendNewLine: false) // yeni bir satır eklemeden yazar.
+
+// variables (var) değer atandıktan sonra değiştirilebilir.
+// constants (let) değer atndıktan sonra değiştirilemez.
+
+var degiskenim = 42
+let øπΩ = "deger" // unicode degişken adları
+let π = 3.1415926
+let convenience = "keyword" // bağlamsal değişken adı
+let isim = "ahmet"; let soyad = "un" // farklı ifadeler noktalı virgül 
+kullanılarak ayrılabilir.
+let `class` = "keyword" // rezerve edilmiş keywordler tek tırnak içerisine 
+alınarak değişken adı olarak kullanılabilir
+let doubleOlduguBelli: Double = 70
+let intDegisken = 0007 // 7
+let largeIntDegisken = 77_000 // 77000
+let etiket = "birseyler " + String(degiskenim) // Cast etme
+let piYazi = "Pi = \(π), Pi 2 = \(π * 2)" // String içerisine değiken yazdırma
+
+
+// Builde özel değişkenler
+// -D build ayarını kullanır.
+#if false
+    print("yazılmadı")
+    let buildDegiskeni= 3
+#else
+    let buildDegiskeni = 7
+#endif
+print("Build degiskeni: \(buildDegiskeni)") // Build degeri: 7
+
+/*  
+    Optionals Swift dilinde bazı değerleri veya yokluğu (None) bir değişkende 
+    	tutmanıza olanak sağlar.  
+    
+    Swift'te her bir degişkeninin bir değeri olması gerektiğinden, nil değeri 
+    	 bile Optional değer olarak saklanır.
+
+    Optional<T> bir enum'dır.
+*/
+var baziOptionalString: String? = "optional" // nil olabilir.
+// yukarıdakiyle aynı ama ? bir postfix (sona eklenir) operatördür. (kolay 
+okunabilir)
+var someOptionalString2: Optional<String> = "optional"  
+
+
+if baziOptionalString != nil {
+    // ben nil deÄŸilim
+    if baziOptionalString!.hasPrefix("opt") {
+        print("ön eki var")
+    }
+    
+    let bos = baziOptionalString?.isEmpty
+}
+baziOptionalString = nil
+
+// belirgin olarak acilan(unwrap) opsiyonel (optional) deÄŸer
+var acilanString: String! = "DeÄŸer bekleniliyor"
+//yukarıdakiyle aynı ama ! bir postfix operatördür (kolay okunabilir)
+var acilanString2: ImplicitlyUnwrappedOptional<String> = "DeÄŸer bekleniliyor."
+
+if let baziOpsiyonelSabitString = baziOptionalString {
+    // eÄŸer bir deÄŸeri varsa, nil deÄŸilse
+    if ! baziOpsiyonelSabitString("tamam") {
+        // ön eke sahip değil
+    }
+}
+
+// Swift deÄŸiÅŸkenlerde herhangi bir tip saklanabilir.
+// AnyObject == id
+// Objective-C deki `id` den farklı olarak, AnyObject tüm değişkenlerle
+ çalışabilir (Class, Int, struct, etc)
+var herhangiBirObject: AnyObject = 7
+herhangiBirObject = "Değer string olarak değişti, iyi bir yöntem değil ama mümkün"
+
+/*
+    Yorumlar buraya
+    
+    /*
+        İç içe yorum yazılması da mümkün
+    */
+*/
+
+//
+// MARK: Koleksiyonlar
+//
+
+/*
+    	Array ve Dictionary tipleri aslında structdırlar. Bu yüzden `let` ve `var` 
+    	ayrıca bu tipleri tanımlarken değişebilir(var) veya değişemez(let) 
+    	olduÄŸunu 	belirtir.
+    	
+*/
+
+// Diziler
+var liste = ["balik", "su", "limon"]
+liste[1] = "ÅŸiÅŸe su"
+let bosDizi = [String]() // let == deÄŸiÅŸtirilemez
+let bosDizi2 = Array<String>() // yukarıdakiyle aynı
+var bosDegistirilebilirDizi = [String]() // var == deÄŸiÅŸebilir
+
+
+// Dictionary
+var meslekler = [
+    "Kamil": "Kaptan",
+    "Ayse": "Analist"
+]
+meslekler["Cansu"] = "Halkla Ä°liÅŸkiler"
+let bosDictionary = [String: Float]() // let == deÄŸiÅŸtirilemez
+let bosDictionary2 = Dictionary<String, Float>() // yukarıdakiyle aynı
+var bosDegistirilebirDictionary = [String: Float]() // var == deÄŸiÅŸtirilebilir
+
+
+//
+// MARK: Kontroller
+//
+
+// for döngüsü (dizi)
+let dizi = [1, 1, 2, 3, 5]
+for deger in dizi {
+    if deger == 1 {
+        print("Bir!")
+    } else {
+        print("Bir degil!")
+    }
+}
+
+// for döngüsü (dictionary)
+var dict = ["one": 1, "two": 2]
+for (key, value) in dict {
+    print("\(key): \(value)")
+}
+
+// for döngüsü (aralık)
+for i in -1...liste.count {
+    print(i)
+}
+liste[1...2] = ["et", "yogurt"]
+// ..<  kullanarak son elemanı çıkartabilirsiniz
+
+// while döngüsü
+var i = 1
+while i < 1000 {
+    i *= 2
+}
+
+// do-while döngüsü
+do {
+    print("merhaba")
+} while 1 == 2
+
+// Switch
+// Çok güçlü, `if` ifadesenin daha kolay okunabilir hali olarak düşünün
+// String, object örnekleri, ve primitif tipleri (Int, Double, vs) destekler.
+let sebze = "kırmızı biber"
+switch sebze {
+case "sogan":
+    let sebzeYorumu = "Biraz da domates ekle"
+case "domates", "salata":
+    let sebzeYorumu = "İyi bir sandviç olur"
+case let lokalScopeDegeri where lokalScopeDegeri.hasSuffix("biber"):
+    let sebzeYorumu = "Acı bir \(lokalScopeDegeri)?"
+default: // zorunludur (tüm olasılıkları yakalamak icin)
+    let sebzeYorumu = "Corbadaki herseyin tadı güzel"
+}
+
+
+//
+// MARK: Fonksiyonlar
+//
+
+// Fonksiyonlar first-class tiplerdir, yani başka fonksiyon içine konabilir
+// ve parametre olarak geçirilebilirler.
+
+// Swift dökümanlarıylaa birlikte Fonksiyonlar (format as reStructedText)
+
+/**
+    selamlama iÅŸlemi
+
+    :param: isim e isim
+    :param: gun  e A gun
+    :returns: isim ve gunu iceren bir String
+*/
+func selam(isim: String, gun: String) -> String {
+    return "Merhaba \(isim), bugün \(gun)."
+}
+selam("Can", "Salı")
+
+// fonksiyon parametre davranışı hariç yukarıdakine benzer
+func selam2(#gerekliIsim: String, disParametreIsmi lokalParamtreIsmi: String) -> String {
+    return "Merhaba \(gerekliIsim), bugün \(lokalParamtreIsmi)"
+}
+selam2(gerekliIsim:"Can", disParametreIsmi: "Salı")
+
+// Bir tuple ile birden fazla deger dönen fonksiyon
+func fiyatlariGetir() -> (Double, Double, Double) {
+    return (3.59, 3.69, 3.79)
+}
+let fiyatTuple = fiyatlariGetir()
+let fiyat = fiyatTuple.2 // 3.79
+// _ (alt çizgi) kullanımı Tuple degerlerini veya diğer değerleri görmezden
+gelir
+let (_, fiyat1, _) = fiyatTuple // fiyat1 == 3.69
+print(fiyat1 == fiyatTuple.1) // true
+print("Benzin fiyatı: \(fiyat)")
+
+// Çeşitli Argümanlar
+func ayarla(sayilar: Int...) {
+    // bu bir dizidir
+    let sayi = sayilar[0]
+    let argumanSAyisi = sayilar.count
+}
+
+// fonksiyonu parametre olarak geçirme veya döndürme
+func arttirmaIslemi() -> (Int -> Int) {
+    func birEkle(sayi: Int) -> Int {
+        return 1 + sayi
+    }
+    return birEkle
+}
+var arttir = arttirmaIslemi()
+arttir(7)
+
+// referans geçirme
+func yerDegistir(inout a: Int, inout b: Int) {
+    let tempA = a
+    a = b
+    b = tempA
+}
+var someIntA = 7
+var someIntB = 3
+yerDegistir(&someIntA, &someIntB)
+print(someIntB) // 7
+
+
+//
+// MARK: Closurelar
+//
+var sayilar = [1, 2, 6]
+
+// Fonksiyonlar özelleştirilmiş closurelardır. ({})
+
+// Closure örneği.
+// `->` parametrelerle dönüş tipini birbirinden ayırır
+// `in` closure başlığını closure bodysinden ayırır.
+sayilar.map({
+    (sayi: Int) -> Int in
+    let sonuc = 3 * sayi
+    return sonuc
+})
+
+// eger tip biliniyorsa, yukarıdaki gibi, şöyle yapabiliriz
+sayilar = sayilar.map({ sayi in 3 * sayi })
+// Hatta bunu
+//sayilar = sayilar.map({ $0 * 3 })
+
+print(sayilar) // [3, 6, 18]
+
+// Trailing closure
+sayilar = sorted(sayilar) { $0 > $1 }
+
+print(sayilar) // [18, 6, 3]
+
+// Super kısa hali ise, < operatörü tipleri çıkartabildiği için
+
+sayilar = sorted(sayilar, < )
+
+print(sayilar) // [3, 6, 18]
+
+//
+// MARK: Yapılar
+//
+
+// Structurelar ve sınıflar birçok aynı özelliğe sahiptir.
+struct IsimTablosu {
+    let isimler = [String]()
+    
+    // Özelleştirilmiş dizi erişimi
+    subscript(index: Int) -> String {
+        return isimler[index]
+    }
+}
+
+// Structurelar otomatik oluÅŸturulmuÅŸ kurucu metoda sahiptir.
+let isimTablosu = IsimTablosu(isimler: ["Ben", "Onlar"])
+let isim = isimTablosu[1]
+print("Ä°sim \(name)") // Ä°sim Onlar
+
+//
+// MARK: Sınıflar
+//
+
+// Sınıflar, structurelar ve üyeleri 3 seviye erişime sahiptir.
+// Bunlar: internal (default), public, private
+
+public class Sekil {
+    public func alaniGetir() -> Int {
+        return 0;
+    }
+}
+
+// Sınıfın tüm değişkenleri ve metotları publictir.
+// Eğer sadece veriyi yapılandırılmış bir objede
+// saklamak istiyorsanız, `struct` kullanmalısınız.
+
+internal class Rect: Sekil {
+    var yanUzunluk: Int = 1
+    
+    // Özelleştirilmiş getter ve setter propertyleri
+    private var cevre: Int {
+        get {
+            return 4 * yanUzunluk
+        }
+        set {
+            // `newValue ` setterlarda yeni deÄŸere eriÅŸimi saÄŸlar
+            yanUzunluk = newValue / 4
+        }
+    }
+    
+    // Bir değişkene geç atama(lazy load) yapmak
+    // altSekil getter cağrılana dek nil (oluşturulmamış) olarak kalır
+    lazy var altSekil = Rect(yanUzunluk: 4)
+    
+    // Eğer özelleştirilmiş getter ve setter a ihtiyacınız yoksa,
+    // ama bir değişkene get veya set yapıldıktan sonra bir işlem yapmak 
+    // istiyorsanız, `willSet` ve `didSet` metotlarını kullanabilirsiniz
+    var identifier: String = "defaultID" {
+        // `willSet` argümanı yeni değer için değişkenin adı olacaktır.
+        willSet(someIdentifier) {
+            print(someIdentifier)
+        }
+    }
+    
+    init(yanUzunluk: Int) {
+        self. yanUzunluk = yanUzunluk
+        // super.init i her zaman özelleştirilmiş değerleri oluşturduktan sonra
+         çağırın
+        super.init()
+    }
+    
+    func kisalt() {
+        if yanUzunluk > 0 {
+            --yanUzunluk
+        }
+    }
+    
+    override func alaniGetir() -> Int {
+        return yanUzunluk * yanUzunluk
+    }
+}
+
+// Basit `Kare` sınıfI `Rect` sınıfını extend ediyor.
+class Kare: Rect {
+    convenience init() {
+        self.init(yanUzunluk: 5)
+    }
+}
+
+var benimKarem = Kare()
+print(m benimKarem.alaniGetir()) // 25
+benimKarem.kisalt()
+print(benimKarem.yanUzunluk) // 4
+
+// sınıf örneğini cast etme
+let birSekil = benimKarem as Sekil
+
+// örnekleri karşılaştır, objeleri karşılaştıran == (equal to) ile aynı değil  
+if benimKarem === benimKarem {
+    print("Evet, bu benimKarem")
+}
+
+// Opsiyonel init
+class Daire: Sekil {
+    var yaricap: Int
+    override func alaniGetir() -> Int {
+        return 3 * yaricap * yaricap
+    }
+    
+    // Eğer init opsiyonelse (nil dönebilir) `init` den sonra soru işareti
+    // son eki ekle.
+    init?(yaricap: Int) {
+        self.yaricap = yaricap
+        super.init()
+        
+        if yaricap <= 0 {
+            return nil
+        }
+    }
+}
+
+var benimDairem = Daire(radius: 1)
+print(benimDairem?.alaniGetir())    // Optional(3)
+print(benimDairem!. alaniGetir())    // 3
+var benimBosDairem = Daire(yaricap: -1)
+print(benimBosDairem?. alaniGetir())    // "nil"
+if let daire = benimBosDairem {
+    // benimBosDairem nil olduğu için çalışmayacak
+    print("circle is not nil")
+}
+
+
+//
+// MARK: Enumlar
+//
+
+// Enumlar opsiyonel olarak özel bir tip veya kendi tiplerinde olabilirler.
+// Sınıflar gibi metotlar içerebilirler.
+
+enum Kart {
+    case Kupa, Maca, Sinek, Karo
+    func getIcon() -> String {
+        switch self {
+        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
+
+// Integer olmayan enumlar direk deÄŸer (rawValue) atama gerektirir.
+enum KitapAdi: String {
+    case John = "John"
+    case Luke = "Luke"
+}
+print("Name: \(KitapAdi.John.rawValue)")
+
+// DeÄŸerlerle iliÅŸkilendirilmiÅŸ Enum
+enum Mobilya {
+    // Int ile iliÅŸkilendirilmiÅŸ
+    case Masa(yukseklik: Int)
+    // String ve Int ile iliÅŸkilendirilmiÅŸ
+    case Sandalye(String, Int)
+    
+    func aciklama() -> String {
+        switch self {
+        case .Masa(let yukseklik):
+            return "Masa boyu \(yukseklik) cm"
+        case .Sandalye(let marka, let yukseklik):
+            return "\(brand) marka sandalyenin boyu \(yukseklik) cm"
+        }
+    }
+}
+
+var masa: Mobilya = .Masa(yukseklik: 80)
+print(masa.aciklama())     // "Masa boyu 80 cm"
+var sandalye = Mobilya.Sandalye("Foo", 40)
+print(sandalye.aciklama())    // "Foo marka sandalyenin boyu 40 cm"
+
+
+//
+// MARK: Protokoller
+//
+
+// `protocol` onu kullanan tiplerin bazı özel değişkenleri, metotları,
+// tip metotlarını,opertörleri ve alt indisleri (subscripts) içermesini
+// zorunlu hale getirebilir.
+
+protocol SekilUretici {
+    var aktif: Bool { get set }
+    func sekilOlustur() -> Sekil
+}
+
+// @objc ile tanımlanan protokoller, uygunluğu kontrol edebilmenizi sağlayacak
+// ÅŸekilde opsiyonel fonksiyonlara izin verir
+@objc protocol SekliDondur {
+    optional func sekillendirilmis()
+    optional func sekillendirilebilir() -> Bool
+}
+
+class BenimSeklim: Rect {
+    var delegate: SekliDondur?
+    
+    func buyut() {
+        yanUzlunluk += 2
+
+	// Bir çalışma zamanı hatası("optional chaining") fırlatmak yerine nil 
+	//değeri görmezden gelerek nil dönmek için opsiyonel değişken, metot veya
+	// altindisten sonra soru iÅŸareti koyabilirsiniz.
+        if let izinVeriyormu = self.delegate?.sekillendirilebilir?() {
+            // önce delegate i sonra metodu test edin
+            self.delegate?.sekillendirilmis?()
+        }
+    }
+}
+
+
+//
+// MARK: DiÄŸerleri
+//
+
+// `extension`lar: Var olan tiplere ekstra özellikler ekleyin
+
+// Kare artık `Printable` protokolüne uyuyor.
+extension Kare: Printable {
+    var description: String {
+        return "Alan: \(alaniGetir()) - ID: \(self.identifier)"
+    }
+}
+
+print("Kare: \(benimKarem)")
+
+// Dahili tipleri de yeni özellikler ekleyebilirsiniz
+extension Int {
+    var customProperty: String {
+        return "Bu sayı \(self)"
+    }
+    
+    func carp(num: Int) -> Int {
+        return num * self
+    }
+}
+
+print(7.customProperty) // "Bu sayı 7"
+print(14.carp(3)) // 42
+
+// Genericler: Java ve C#'a benzer ÅŸekilde. `where` anahtar kelimesini
+// kullanarak genericlerin özelliklerini belirleyin
+
+func indexiBul<T: Equatable>(dizi: [T], bulunacakDeger: T) -> Int? {
+    for (index, deger) in enumerate(dizi) {
+        if deger == bulunacakDeger {
+            return index
+        }
+    }
+    return nil
+}
+let bulunanIndex = indexiBul([1, 2, 3, 4], 3)
+print(bulunanIndex == 2) // true
+
+// Operatorler:
+// Özel operatorler şu karakterlerle başlayabilir:
+//      / = - + * % < > ! & | ^ . ~
+// veya
+// Unicode math, symbol, arrow, dingbat, ve line/box karakterleri.
+prefix operator !!! {}
+
+// Yan uzunluğu 3 katına çıkartan prefix operatörü
+prefix func !!! (inout sekil: Kare) -> Kare {
+    sekil.YanUzunluk *= 3
+    return sekil
+}
+
+// güncel deger
+print(benimKarem.YanUzunluk)  // 4
+
+// yan uzunluğu !!! operatorü kullanarak 3 katına çıkar
+!!!benimKarem
+print(benimKarem.YanUzunluk) // 12
+```