DEV Community: Golang

📧 Sending E-Mail from Gmail Using Golang.

Yusuf Turhan Papurcu — Sun, 01 Jan 2023 15:30:44 +0000

First setup your gmail account like this. You can access here from settings/all settings.

Open Forwarding and POP/IMAP. Enable IMAP and save changes.

Then open Google Account/Security. Open Application Passwords. (You need 2-Step Verification)

Select Post and Other device. I named “Golang Emails”. Then create it.

We get the application password. Let’s Code it!

package main

import (
    "log"
    "net/smtp"
)

func main() {
    send("hello bro, This just test.")
}

func send(body string) {
    from := "yusufturhanp@gmail.com"
    pass := "*****"
    to := "tryusuf97@gmail.com"

    msg := "From: " + from + "\n" +
        "To: " + to + "\n" +
        "Subject: Hello there\n\n" +
        body

    err := smtp.SendMail("smtp.gmail.com:587",
        smtp.PlainAuth("", from, pass, "smtp.gmail.com"),
        from, []string{to}, []byte(msg))

    if err != nil {
        log.Printf("smtp error: %s", err)
        return
    }
    log.Println("Successfully sended to " + to)
}

You must change from to sender mail, pass to Application Password and “to” to reciver email. Run and look your sended posts.

We sent the first email. And we set up the google account. You can now send as many emails as you want.

Configuration Hot-Reloading nedir?

Melih Sivri — Sat, 09 Apr 2022 12:50:31 +0000

Merhaba, bu yazımda cloud-native web uygulamalarında konfigürasyon yönetiminde kullanılan configuration hot-reloading konseptinden bahsedeceğim. Ufaktan başlayalım.

Öncelikle geleneksel web servislerinde konfigürasyonların nasıl yönetildiğine bakalım. Genelde servis ayağa kalkarken dışarıdaki bir kaynaktan önceden tanımlanmış tüm değerleri alır. Bu kaynak bir environment dosyası, bir configuration manager veya direkt üzerinde çalıştığı işletim sistemi de olabilir. Devamında uygulamamız aldığı değerlerle uygulamada gerekli olan işlemleri yapar ve çalışmaya başlar. Restart atılana kadar konfigürasyon değişiklikleri ile ilgilenmez.

Peki bu sistemde anlık olarak değişiklikleri izleyerek veya dışarıdan tetiklenerek konfigürasyon değiştirme ihtiyacımız neden olsun ?

Bir çok sebebi olabilir ancak en yaygın olanından bahsetmek gerekirse loglama. Sunucunuzda çalışan tüm testlerden geçmiş, sorunsuzca çalıştığına inandığınız bir uygulama düşünün. Bir gün aniden anlam veremediğiniz bir sebepten dolayı istediğimiz gibi çalışmamaya başlıyor. Restart attığınızda ise tekrar çalışır hale geliyor. İlk işiniz logları okumak oluyor ancak loglarda problem görünmüyor çünkü loglama seviyenizden dolayı o an neler olduğuna dair yeterince detay bulamıyorsunuz. Bu büyük bir sistemde oldukça tehlikeli bir durumdur. Pimi çekilmiş bomba gibi gezen bir servisiniz var, her an bozulup diğer servisleri dolayısıyla production ortamını tehlikeye atabilir.

Bunun gibi nadiren karşılaştığınız hatalarda production ortamında mevcut state'i koruyarak yani restart atmadan debugging yapma ihtiyacınız olur. İşte bu anlarda uygulamayı kapatmadan loglama seviyenizi değiştirmek yani hot-reloading için yardımımıza bu pattern yetişiyor.

Aşağıdaki basit web-server uygulamasında bu yapının nasıl çalıştığını görebilirsiniz.

Örnek uygulamanın kodlarına buradan ulaşabilirsiniz. Başka bir yazıda görüşmek üzere...

Kaynak: Justin Garrison, Kris Nova - Cloud Native Infrastructure Patterns for Scalable Infrastructure and Applications in a Dynamic Environment

Rule the JSON operations in Go 🧑‍⚖️

Yusuf Turhan Papurcu — Sat, 19 Mar 2022 14:51:05 +0000

Have you ever wondered how much golang allows you to customize Json operations?

I searched about it and I found that we can declare our methods for json marshal/unmarshal operations. I can't guarantee this information is usable but I think it is nice to know. If you want to know how to do it please keep reading :)

Toying with Json Interfaces

I will give direct code examples in here so firstly there is our code:

Scenario: We have an exampleStruct definition at line:33. This is our user model and it's contain some problematic information in it (Like credit card info). So we want to filter them in json marshal/unmarshal.

Create new data layer

I created a type called emailCover at line:51. I need this layer because I don't want to create recursive marshaling loop in my method by using json.Marshal(). You don't need to do it but I think it is more safe for avoiding stack overflow.

Filter Coming Data in `json.Unmarshal()`

We implemented an UnmarshalJSON method to our cover at line:53. It basically just unmarshall all data and gives us necessary fields.

Important: Don't forget declare object as pointer in method definition.

Don't Marshal Data in `json.Marshal()`

We implemented an MarshalJSON method to our cover at line:64. It basically just get default version of object and just sets necessary fields. And returns json.Marshal() again. Did you notice? We put exampleStruct insde return marshal. If you try to give emailCover you cause a recursion. And this causes an stack overflow error.

Important: Don't forget declare object as value in method definition.

Extra Point

Documentation says:

Marshal traverses the value v recursively. If an encountered value implements the Marshaler interface and is not a nil pointer, Marshal calls its MarshalJSON method to produce JSON. If no MarshalJSON method is present but the value implements encoding.TextMarshaler instead, Marshal calls its MarshalText method and encodes the result as a JSON string. The nil pointer exception is not strictly necessary but mimics a similar, necessary exception in the behavior of UnmarshalJSON.

So this methods called in inheritor objects also.

Referances

encoding/json document: https://pkg.go.dev/encoding/json

⌛️ Manage time specified operations with Go in easy way.

Yusuf Turhan Papurcu — Sat, 19 Feb 2022 16:06:39 +0000

In programming we need specifying time for our code. Sometimes we wait until our crush end her relationship. Sometimes we wait until summer to change our job.

Let's Start!

For doing thing with specified time I will show the basics in Go. In the first part we will look 2 simple code part. After we will discuss about how can we improve them and make it usable even production environment.

Part 1 — Basics Of Time Specifying in Go

For time specifying we will use 2 basic technique. First one is for blocking current goroutine until specified time.

In this example goroutine blocked for 5 second at 3rd line and continues after this. If you want waiting more time and doing more readable. You can use time.Until(). Here a basic example for this.

Second technique is blocking goroutine forever and make it cron engine. For doing this we have an excellent function called time.Tick(). This method takes duration and returns channel that triggers at every duration loop.

If you don’t care about current time and just want to execute code continuously you can use this one. Also this way is more manageable and allow control flow with context or specific trigger channels.

Part 2 — Let’s Improve Them With Context Package

Context package is so useful. Because Context gives you a power of cancellation. You can cancel functions with it. If you are doing things with time, context is like Thor’s Mjölnir for you.

Key part of using context is based on for { select{…} } loop. Also you must use async for be able to use context. Because If your code flow don’t run, you can’t cancel the context.

Let’s do some examples. First we will implement a basic wait function with context. If context cancel called before timer end, function will exit without wait to timer end. In that case our program just wait 5 second instead of 5 minutes. That can annoy your goroutine :)

For key point. We split our waiting routine and main routine. We must do that because if we didn’t do that we can’t call cancel function asynchronously.

Creating cron engine with context is basic than previous example. Just add context.Done() to the select statement.

For a final example I want to add more complex, beautiful and useful cron engine example from here. I won’t add code to article. You can use link for this. Also this repository is a great implementation and my inspiration for writing this article.

https://github.com/stephenafamo/kronika

I would like to hear all feedback’s about this article. Please feel free to give feedback. I want to hear all of good and bad feedbacks :)

I’m planning to expand this article some. If you have an idea what can I talk about at the feature of this article, I want to hear it.

Inspired Articles

https://stephenafamo.com/blog/posts/better-scheduling-in-go

Good Repositories

Using BoltDB as internal database 💾

Yusuf Turhan Papurcu — Sat, 15 Jan 2022 11:30:46 +0000

If you are looking for a small database for your fun project, I have something you might like. It is small, works as a key-value store and it's pure go.

What is Bolt?

Bolt is a pure Go key/value store inspired by Howard Chu's LMDB project. The goal of the project is to provide a simple, fast, and reliable database for projects that don't require a full database server such as Postgres or MySQL.

Since Bolt is meant to be used as such a low-level piece of functionality, simplicity is key. The API will be small and only focus on getting values and setting values. That's it.

How to use Bolt?

Installing

Bolt doesn't need any install other than go get. It just works as a library. So your only need is adding it to go.mod file.

go get github.com/boltdb/bolt

Creating database

After you can create your database like this.

    db, err := bolt.Open("my.db", 0600, &bolt.Options{})
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

In here you can add timeout to your database. Or you can set readonly if you don't need writing into. Just set them in &bolt.Options{}.

Writing into database

You need to create bucket first. After than you can write your key/value data into bucket. Also tx.CreateBucketIfNotExists([]byte) function is life saver.

    db.Update(func(tx *bolt.Tx) error {
        bucket, err := tx.CreateBucketIfNotExists([]byte("todo"))
        if err != nil {
            return fmt.Errorf("create bucket: %s", err)
        }
        return bucket.Put([]byte("task-1"), []byte("Test BoltDB"))
    })

If you have a bucket already you can write into it like this. Caution checking bucket is nil is important. Because if you try to use Put on nil bucket your program will panic.

    db.Update(func(tx *bolt.Tx) error {
        bucket := tx.Bucket([]byte("todo"))
        if bucket == nil {
            return fmt.Errorf("get bucket: FAILED")
        }
        return bucket.Put([]byte("task-1"), []byte("Test BoltDB additions"))
    })

Querying data from database

Querying is as simple as writing. Just call your bucket and ask it for your data.

    db.View(func(tx *bolt.Tx) error {
        b := tx.Bucket([]byte("todo"))
        if b == nil {
            return fmt.Errorf("get bucket: FAILED")
        }
        fmt.Println(b.Get([]byte("task-1")))
        // should return nil to complete the transaction
        return nil
    })

And here is simple way to iterate on all keys in one bucket.

    db.View(func(tx *bolt.Tx) error {
        b := tx.Bucket([]byte("todo"))
        if b == nil {
            return fmt.Errorf("get bucket: FAILED")
        }
        // we need cursor for iteration
        c := b.Cursor()
        for k, v := c.First(); k != nil; k, v = c.Next() {
            fmt.Println("Key: ", string(k), " Value: ", string(v))
        }
        // should return nil to complete the transaction
        return nil
    })

Conclusion

Bolt is a pure Go key/value store
Bolt is native go library
Bolt is supported everywhere which go is supported
Creating, Writing and Querying inside Bolt is really easy.

Simple and powerful toolkit for BoltDB

Storm is a simple and powerful toolkit for BoltDB. Basically, Storm provides indexes, a wide range of methods to store and fetch data, an advanced query system, and much more.
GitHub: https://github.com/asdine/storm

Future Readings

Go Smtp ve RabbitMQ ile Email servisi

Tayfur — Fri, 03 Dec 2021 13:23:51 +0000

Selamlar Ben Tayfur Kaya yeni Golang öğreniyorum ve size öğrenirken yaşadığım zorlukları ve avantajları bu projede göstermek istiyorum.
Bugün go dili ile yazmış olduğum basit bir email service inceleyeceğiz.
kullandığım teknolojiler RabbitMQ, Smtp, fiber ve Gorm
Github Reposuna gitmek istiyorsanız Github

Stmp

Golang ile basit bir sekilde gönderici olan mail adresine giriş yaparak istediğimiz email adresine mesajı html template olarak göndereceğiz

Html nasıl parse edilir ?

 template.ParseFiles("./Templates/FeatureNotification.html")

yukarıda html dosyasını parse ediyoruz.
ve aşağıdaki gibi execute ediyoruz buradaki subject kısmı ise gönderilecek mailin title yazıyoruz..

templateBuffer.Write([]byte(fmt.Sprintf("Subject: Lates Features \n%s\n\n", mimeHeaders)))
    t.Execute(&templateBuffer, nil)

Smtp ile mail göndermek

sendMail fonksiyonu hangi consumerden triggerlandıysa ilgili htmli parse ediyoruz

    switch tamplate {
    case "WelcomeQueue":
        body = parseHtml.WelcomeTemplate()
        break
    case "WeeklyReportQueue":
        body = parseHtml.WeeklyReportTemplate()
        break
    case "FeatureNotificationQueue":
        body = parseHtml.FeatureNotificationTemplate()
        break
    }

err := smtp.SendMail(smtpHost+":"+smtpPort, auth, senderMail, to, []byte(body))

yukaradaki kod bloğunda mail adresimize authentication oluyoruz ve oldugumuz email adresinden to göndereceğimiz mail adresini içeriyor. msg kısmı ise gönderilecek olan mesajı içeriyor ama biz orada bir mesaj yerine html template göndereceğiz.

RabbitMQ

diyebilirsinizki yukarıda basit yazıyordu ne gerek var rabbitMQ kullanmaya!

Evet var çünkü gönderecek oldugumuz mailleri Message queue
ya göndermemiz gerekiyor, yaptıgımız app belki databaseden aldığımız mail adreslerine email atarken yarısında app crashe olabilir ve biz hangi mail adreslerine mail gönderildi hangisine gönderilmedi bunu bilemeyiz.

Birden fazla email templatemiz olabilir mesela welcome, verify, Feature Notification gibi farkettiginiz gibi bazıları Bulk(toplu gönderilen) mail bazıları Transaction(tekli ) mail.

Biz her template icin bir Consume ve Publish oluşturacağız böylelikle mail adresleri ilk önce queue gidicek sonra Consume"a iletilecek ve oradan templatine göre smtp ile maili göndereceğiz =)

Publish

RabbitMQ bağlantısı oluşturuyoruz

connectRabbitMQ, err := amqp.Dial(amqpServerURL)

consume ile haberleşmek için bir channel oluşturuyoruz

channelRabbitMQ, err := connectRabbitMQ.Channel()

yeni bir mesaj oluşturup bunu queue gönderiyoruz ama burdaki en önemli nokta verilen queue name"i çok önemli bu fonksiyonun çağrıldığı yerden alıyor ve mesajı o queue ismine göre gönderiyor bu sayede consume ederken her template icin farklı queue den onları alabileceğiz

    message := amqp.Publishing{
        ContentType: "text/plain",
        Body:        msg,
    }

    // mesaji publish eder.
    if err := channelRabbitMQ.Publish(
        "",// exchange
        queueName,// queue name
        false,
        false,
        message,
    ); err != nil {
        return err
    }

Consume

buradaki işlemlerde aynı sayılır ama bir farkla =)
queue deki mesajları okuyup her mesaj için bir sendMail fonksiyonunu trigger ediyor

    forever := make(chan bool)
    go func() {
        for message := range messages {
            to := []string{string(message.Body)}
            //queue'dan gelen mesaji mail.Send fonksiyonuna gönder
            mail.SendMail(to, queueName)
            log.Printf(" > Received message: %s\n", message.Body)
        }
    }()

    <-forever

Bulk Mail & Transaction Mail

Yukarıda bu ikisinden bahsetmiştik genel anlamda toplu gönderilen maillere Bulk ,ve sadece tekli işlemler için gönderilen maillere Transaction mail denir

    db, err := db.ConnectDB()
    if err != nil {
        log.Fatal(err)
        panic(err)
    }
    var User []models.User
    db.Find(&User)

yukarıda diye bağlanıp dbdeki User ların hepsini arrayin içine alıyoruz
Aşağıda is User arrayini for döngüsüne alıp her user"ın maili için []byte a dönüştürüp bunu queue gönderiyoruz burada []byte a dönüştürmemizin sebebi RabbitMQ channeli byte ile haberleşmesi

    for _, t := range User {
        var to []byte
        to = []byte(t.Email)
        rabbitmq.Publisher(to, template)
    }

Transaction maillerinde ise farklı farklı işlemler yapılabilir ama biz basit bir halde fiber endpointinden gelen mail adresine email göndereceğiz

Main

Main fonksiyonu içinde goroutine ile bütün consumeleri dinliyoruz bunlar hep açık kalıyor queue herhangi bir mail girdiğinde direkt bunları işleme gönderecek

WelcomeQueue := "WelcomeQueue"
    WeeklyReportQueue := "WeeklyReportQueue"
    FeatureNotificationQueue := "FeatureNotificationQueue"
    // consumelari dinliyoruz
    go rabbitmq.Consume(WeeklyReportQueue)
    go rabbitmq.Consume(FeatureNotificationQueue)
    go rabbitmq.Consume(WelcomeQueue)

Dediğim gibi Mailleri gönderirken fiber endpointleri trigger edicek aslında daha complex hale getirilebilir örneğin eğer diye yeni bir kullanıcı eklendiyse o indexteki maile welcomeTemplati göndermek gibi ama şimdi daha basit bir şekilde handle ediyoruz

    app := fiber.New()
    app.Use(
        logger.New(), // add simple logger
    )

    app.Get("/FeatureNotification", func(c *fiber.Ctx) error {
        go logic.BulkMail(FeatureNotificationQueue)
        return c.SendString("Feature notification Sended")
    })
    app.Get("/WelcomeNotification", func(c *fiber.Ctx) error {
        msg := []byte(c.Query("msg"))
        logic.Transactional(msg,WelcomeQueue)
        return c.SendString("Welcome Sended to "+string(msg))
    })

conclusion

Bence go yazması çok keyifli bir dil ve kolayca service oluşturabiliyorsunuz eğer sizde benim gibi başka yazılım dillerinden geldiyseniz variables'a önem verin çünkü verileri çok defa convert etmem gerekti
umarım yazımı beğenmişsinizdir, yazım yanlışları için özür dilerim elimden geldiğince anlaşılır yazmaya çalıştım

Go ile Algoritmalar — QuickSort

Yusuf Turhan Papurcu — Sun, 28 Nov 2021 08:37:13 +0000

Bu gün Go ile QuickSort algoritmasını yazacağız. Bunun için harici bir kütüphaneye ihtiyacımız yok.

Kısaca QuickSort algoritmasına değinmek gerekirse bu algoritma “Böl ve Fethet” mantığı ile çalışır. Eldeki veri kümesini sürekli daha da küçülterek sonuca ulaşır. Tabiki bu yöntem tamamen dağınık listelerde çok iyi çalışırken ne yazık ki sıralanmış listelerde düşük performans verir. Sebebini anlamak için öncelikle algoritmanın mantığını iyice kavramak gerekiyor. Bunun için buyrun çalışma sürecini açıklayalım ve 10 elemanlık bir dizide deneyelim.

QuickSort algoritması verilen liste içerisinde öncelikle bir Dayanak (Pivot) belirler. Bunun için çeşitli teknikler kullanılmaktadır. Mesela 1961'de QuickSort’un ilk yayınlandığı makalede dayanak olarak ilk elemanın seçilmesi tavsiye ediliyordu. Fakat daha sonrasında bunun yerine listeden rastgele bir eleman seçilmesinin daha mantıklı olduğu ortaya çıktı. Çünkü Quicksort seçtiği dayanağa göre ikiye ayrılır. Dayanaktan küçükler ve dayanaktan büyükler. Bunu liste iki elemanlı hale gelene kadar tekrar eder. Sonra elde ettiği tüm listeleri birleştirir ve sıralanmış listeyi ortaya çıkarır. Eğer liste zaten sıralanmış ise tüm değerler dayanaktan büyük çıkar ve liste sadece 1 eleman eksik olarak ikiye ayrılır. Bu da listenin eleman kadar bölünmesi anlamına gelir. Bu olabilecek en kötü seneryodur. Bunu engellemek için de genellikle dayanak liste içinden rastgele seçilir. Ben dayanağımı şu şekilde seçeceğim.

// Dayanak Seçimi
pivot := rand.Int() % len(dizi)

Dayanağımı almak için rastgele bir sayı tuttum ve onu dizimin uzunluğuna böldüm. Böylece yukarıdaki performans kaybını minimize edeceğim.

if len(dizi) < 2 {
  return dizi
  }
left, right := 0, len(dizi)-1

Burada da gelen dizi tek elemanlı olursa fonksiyonun return etmesini sağladım. Bu kısmın amacı hatalı veri girişine engel olmak değil, fonksiyonun recursive (özyinelemeli) çalışmasını sağlamak.

Ardından dizimin uzunluğunu da kullanarak ilk ve son elemanı aldım. Bu dizimi ikiye ayırırken gerekli olacak. Bundan sonra diziyi dayanğa göre ikiye ayırıp yeniden fonksiyona sokmak gerekiyor. Bunu da basit ve kullanışlı bir for döngüsü ile yapacağız.

dizi[pivot], dizi[right] = dizi[right], dizi[pivot]

for i := range dizi {
    if dizi[i] < dizi[right] {
        dizi[left], dizi[i] = dizi[i], dizi[left]
        left++
    }
}

dizi[left], dizi[right] = dizi[right], dizi[left]

Satır satır açıklamak gerekirse:

İlk önce seçilen dayanak ile son elemanın yerlerini değiştiriyorum.
Sonrasında Diziyi elemanları uzunluğunda bir döngüye sokuyorum.
Ondan sonra listenin i indexindeki sayı dayanaktan küçük ise sola atıp left değişkenimi bir arttırıyorum.
Sonrasında dizinin son elemanı ile döngüde değeri değişen left’in yerini değiştiriyorum.

Bundan sonra yapılacak tek şey dizinin sol ve sağ taraflarını tekrardan bu döngüye sokmak.

quickSort(dizi[:left])
quickSort(dizi[left+1:])

return dizi

Bu da gayet basit.

Ve en sonunda tüm fonksiyon bu hale geliyor.

func quickSort(dizi []int) []int {
    if len(dizi) < 2 {
        return dizi
    }

    left, right := 0, len(dizi)-1

    rand.Seed(int64(len(dizi)))

    // Dayanak Seçimi
    pivot := rand.Int() % len(dizi)

    dizi[pivot], dizi[right] = dizi[right], dizi[pivot]

    for i := range dizi {
        if dizi[i] < dizi[right] {
            dizi[left], dizi[i] = dizi[i], dizi[left]
            left++
        }
    }

    dizi[left], dizi[right] = dizi[right], dizi[left]

    quickSort(dizi[:left])
    quickSort(dizi[left+1:])

    return dizi
}

Tüm kodu ve Test fonksiyonunu Github Depomda bulabilirsiniz.

Golang Nedir?

Metecan Kaplan — Sun, 21 Jun 2020 19:48:07 +0000

Merhaba, bu benim ilk blog yazım ve heyecanla yazıyorum.
Bu ilk yazımda Go programlama dilini ya da kısaca Go'yu ele alacağım.

(Go, Golang, Google Go ya da Go programlama dili olarak da hitap edilir.)

İlk olarak Go ile nasıl tanıştığımdan bahsetmek istiyorum;
2019'un Aralık ayının birinci gününde Antalya'da gerçekleşen Antalya GDG DevFest'19 etkinliğinde, Sayın Ecir Uğur Küçüksille'nin Go dilini ele aldığı sunumu ile tanıma fırsatım oldu.

İlk başta pek ilgilenmesem de yakın zamanda Go'ya olan ilgim epeyce arttı. İlgimin artması ile birlikte öğrendiklerimi paylaşma hevesim de bir o kadar arttığını fark ettim ve şu anda bu satırları yazıyorum.

Lafı uzatmadan konuya giriş yapmak iyi olacaktır. 🙂

Golang nedir?

Golang, İlk olarak Google'ın kendi içerisinde barındırdığı sistemleri daha hızlı, güvenli ve verimli hale getirmek amacıyla Rob Pike, Robert Griesemer ve Ken Thompson tarafından tasarlanan, açık kaynak ve statik tipli yazılan bir programlama dilidir.

Go, 2007 yılında bu 3 başarılı mühendis tarafından tasarlanmaya başlandı ve 2009 yılında ilk versiyonu piyasaya sürüldü.

Google'ın hedefi diğer dillerdeki en iyi yönleri alıp, sorunlu yanlarını çözümleyip tek dilde birleştirmekti ve kısmen bunu başardı.

Bir çok şirket alt sistemleri için Go'yu tercih ediyor fakat bu Go'nun sadece alt sistemler için kullanıldığı anlamına gelmiyor.

Go, içerisinde 25 anahtar sözcük(keyword) bulunduruyor ve bu da dili sade kılıyor.

Dilin yakın zamanda bu kadar popüler olmasının etmenlerinden biri de maskotu olan Gopher isimli sevimli sincap kesinlikle. Ayrıca Go dilini kullanan geliştiricilere de Gopher denmekte.

Pekala Go hakkında bir kaç şey biliyoruz peki neden tercih etmelisiniz?

Go'yu neden tercih etmelisiniz?.

Go size C dilinde elde ettiğiniz performansa çok yakın bir performans sağlar.
Go eşzamanlı çalışmayı doğal olarak destekleyen bir dildir.
Geriye yönelik bir dildir yani Go'nun ilk sürümünde yazılmış bir program'ı başka sürümlerde de sorunsuz çalıştırabileceğiniz anlamına geliyor.
Az vakitte çok iş teriminin karşılığını verir. Bu şu anlama gelir; Go yorumlanabilir dilden ziyade derlenebilir bir dil olduğundan, sanal makinelere ihtiyaç duymadan direkt olarak doğal makine diline çevrilir bu da size zaman kazandırır.
Go esnek bir dildir, size bir çok alanda ürün çıkarmanıza olanak sağlar. Go ile sistem ve ağ programlama, makine öğrenmesi, big data(büyük veri), web, mobil, CLI ve masaüstü alanlarında ürün çıkarabilirsiniz. (Go bahsettiklerimin bir kaçını kendi içerisinde bulundurmasa da yazdığım tüm alanlarda ürün çıkarmanız mümkün)
Go, ayrılan belleğin düzgünce yönetimini sağlar.
Kendi çöp toplayıcısına sahiptir. (Garbage Collector ya da GO GC)

Go en çok hangi kısımlar için tercih ediliyor?

Ölçeklenebilir, yüksek performanslı uygulamalar için.
Web alanında Back-End (Arka uç) kısmı için.
Bir çok medya şirketi içerisindeki ağır yükleri azaltmak için (Netflix, YouTube, SoundCloud vb.).
Dahili analiz hizmetleri için.
Cloud Computing(Bulut bilişim) için.

ve daha fazla alanlarda kullanılmakta.

Go kullanan şirketler

Google
Uber
Medium
Trendyol
SoundCloud
Dropbox
Netflix
YouTube
Peak Games

daha fazlasını Go'nun GitHub sayfasındaki GoUsers bölümünde bulabilirsiniz.

Go hakkındaki kişisel görüşüm

Go benim için ideal bir dil, kullandığım dillere nazaran Go'ya daha fazla ısındım, benim için aileden biri gibi. Go dilinin rahat ve kolay kullanımı da beni kendisine çekti diyebilirim. Henüz ciddi işler için kullanmasam da kullanacağım kesinlik kazandı.

Kısaca artık ben de bir Gopher'ım. 😊

Bu yazımda eksik, hatalı veya sorunlu kısımlar fark ettiyseniz bana kişisel sitemden ulaşabilirsiniz.