Microsoft’un CEO’su açıkladı: Artık SaaS uygulama backendleri yerine yapay zeka ajanlarından oluşan backendler hazırlamalıyız. Yapay zeka ajanlarınızı Microsoft AutoGen, CrewAI ve LangChain gibi kütüphanelerle hazırlayabilirsiniz.

Backend’inizde AutoGen kullanıyorsanız yapay zeka ajanınızı .NET veya Python ile hazırlayabilirsiniz. CrewAI kullanıyorsanız Python ile; eğer LangChain kullanıyorsanız backendinizi NodeJS veya Python ile hazırlayabilirsiniz.

Yerli sanal asistan olan enGrehber projesinde yapay zeka ajanlarımızı Python ile hazırladık/hazırlıyoruz. LangChain kütüphanesinden yararlanarak bir OpenAI Ajanı bir de Gemini Ajanı hazırladık. İşte tam bu aşamada Türkçe ve İngilizce dil seçenekleri üzerinde çalışırken yerelleştirme (localization) yapmamız gerekti.

Python’da Yerelleştirme

Python’da yerelleştirme nasıl yapılır diye araştırırken karşıma “locale” kütüphanesi çıktı. Locale kütüphanesini öğrenmek için şu makaleyi okumanızı tavsiye ediyorum:

https://phrase.com/blog/posts/beginners-guide-to-locale-in-python/

Ancak bu ve bunun gibi makaleler yeterli sayılmaz. Locale kütüphanesine ek olarak “gettext” kütüphanesini de kullanmanız gerekiyor.

Python’daki gettext kütüphanesi, uygulamanızı yerelleştirmek için uluslararasılaştırma (i18n) işlemlerinde kullanılır. Bu kütüphanenin temel amacı, belirli bir dil ve bölgeye uygun metin çevirileri sağlamak ve kullanıcıya sunmaktır. Aşağıda, bu metodun nasıl kullanılacağını ve sağladığı temel özellikleri görebilirsiniz:

Temel Kullanım

gettext metodu, bir metni çevirmek için kullanılır. Bu metot, bir çeviri dosyasındaki uygun metni alır ve onu geri döner.

Adımlar

1. Çeviri Dosyaları (mo veya po) Oluşturma: İlk adımda, çevirileri içeren .mo veya .po dosyalarını oluşturmanız gerekir. Örneğin, messages.po dosyasını aşağıdaki gibi oluşturabilirsiniz:

messages.po:

msgid "Hello, World!"
msgstr "Merhaba, Dünya!"

2. Çeviri Dosyalarını Yükleme ve gettext Kullanımı: Daha sonra, çeviri dosyalarını yükleyerek ve gettext metodunu kullanarak metin çevirilerini alabilirsiniz.

Örnek Kod

import locale
import gettext

# Yerelleştirme dosyalarının bulunduğu dizin
localedir = './locale'

# Hedef dili ve kodlamayı belirle
locale.setlocale(locale.LC_ALL, 'tr_TR.UTF-8')

# Çeviri dosyasını yükleme
gettext.bindtextdomain('messages', localedir)
gettext.textdomain('messages')
_ = gettext.gettext

# Metinleri çevirme
translated_text = _("Hello, World!")
print(translated_text)  # Çıktı: Merhaba, Dünya!

Açıklama:

1. Yerelleştirme Dosyaları: gettext ile kullanılacak çeviri dosyalarını belirtin. locale dizini, çevirilerin bulunduğu dizin olarak tanımlanır.
2. locale Ayarları: locale.setlocale ile hedef dili ve kodlamayı belirleyin.
3. gettext Bağlama ve Kullanma: gettext.bindtextdomain ile çeviri dosyasının yerini belirtin, gettext.textdomain ile kullanılacak dosyayı seçin ve gettext metodunu _ kısayolu ile kullanın.
4. Metin Çevirisi: _ kısayolu ile çeviri metinlerini alın ve kullanın.

Bu şekilde, uygulamanızı çok dilli hale getirebilir ve farklı dillerde kullanıcı deneyimi sunabilirsiniz.

Unsupported Locale Hatası

Her şey çok güzel de, kodu sunucuda çalıştırdığımızda Unsupported Locale hatası alırsak ne yapacağız? Bununla ilgili StackOverflow sayfasını aşağıda paylaşıyorum:
https://stackoverflow.com/questions/14547631/python-locale-error-unsupported-locale-setting

Sonuç

.NET, NodeJS veya Python ile hazırladığınız yapay zeka ajanlarınızı hazırlarken backendlerimizde LLM’lerden yararlanıyoruz. Böylece sanal asistan backendleri ya da yapay zeka ile güçlendirilmiş diğer backendler hazırlamamız mümkün hale geliyor. LangChain, CrewAI ve AutoGen kütüphaneleri yapay zeka ajanları hazırlama sürecini oldukça kolaylaştırıyor.

Mutlu kodlamalar

Web ve mobil uygulamalarında erişilebilirlik standartlarına uyma zorunluluğu ülkemizde de yürürlüğe girmek üzere. Artık web ve mobil uygulamaları hazırlarken W3C ve ISO standartlarına uygun hazırlamakla kalmayıp, test araçlarıyla erişilebilirlik kriterine uygunluğu test etmelisiniz. Ayrıca VoiceOver ve TalkBack gibi uygulamaları ve Braille klavyeyi kullanarak görme engelliler için uygunluğu da ayrıca test etmelisiniz.

Bu makalenin kalan kısmında WCAG 2.2 standardının madde madde özetini paylaşıyor olacağım. Bu erişilebilirlik standartının tam içeriğine W3C’nin sitesinden erişebilirsiniz. Ayrıca Cumhurbaşkanlığı da bir erişilebilirlik genelgesi yayınlamak üzere. WCAG 2.2’nin Türkçe özeti aşağıdadır:

Web İçeriği Erişilebilirlik Yönergeleri (WCAG) 2.2

WCAG (Web Content Accessibility Guidelines) 2.2, erişilebilirlik ilkelerini ve başarı ölçütlerini dört ana başlık altında toplar: Algılanabilirlik, İşletilebilirlik, Anlaşılabilirlik ve Sağlamlık. WCAG 2.2’nin getirdiği ek kuralları içerecek şekilde tüm ilkeleri ve kuralları madde madde şu şekilde sıralayabilirim:

1. Algılanabilirlik

Web içeriği, herkes tarafından algılanabilir olmalıdır.

1.1 Metin Alternatifleri

• 1.1.1 Metin Alternatifi: Görsel içerikler için metin alternatifleri sağlanmalıdır.*

1.2 Zamanla Kontrol Edilen Medya

• 1.2.1 Yalnızca Ses veya Görüntü (Ön Kayıtlı): Alternatif metin veya medya açıklamaları sağlanmalı.
• 1.2.2 Altyazılar (Ön Kayıtlı): Videolarda altyazı kullanılmalı.
• 1.2.3 Ses Açıklamaları veya Alternatifler (Ön Kayıtlı): Ses açıklaması veya alternatif bir medya sağlanmalı.
• 1.2.4 Altyazılar (Canlı): Canlı videolar için altyazılar sağlanmalı.
• 1.2.5 Ses Açıklamaları (Ön Kayıtlı): Ses açıklamaları eklenmeli.

1.3 İçerik Uyumlu

• 1.3.1 Bilgi ve İlişkiler: Yapısal bilgi, erişilebilir yollarla sunulmalıdır.
• 1.3.2 Anlamlı Sıra: Okuma sırası anlamlı olmalı.
• 1.3.3 Duyusal Özellikler: İçeriği anlamak için yalnızca duyusal unsurlara güvenilmemeli.

1.4 Ayrım ve Okunabilirlik

• 1.4.1 Renk Kullanımı: Bilgi sadece renk ile aktarılmamalı.
• 1.4.2 Ses Kontrolü: Otomatik oynatılan ses kontrol edilebilir olmalı.
• 1.4.3 Kontrast (Minimum): Metin ve arka plan kontrastı yeterli olmalı.
• 1.4.4 Metin Boyutu Yeniden Boyutlandırma: İçerik işlevselliğini kaybetmeden büyütülebilmeli.*
• 1.4.5 Görsellerde Metin: Görsellerde metin kullanımından kaçınılmalı.
• 1.4.10 Yeniden Akış: İçerik, ekran boyutlarına uyumlu olmalı.
• 1.4.11 Kullanıcı Arayüzü Bileşenleri Kontrastı: Arayüz öğeleri kontrastlı olmalı.
• 1.4.12 Metin Aralıkları: Metin aralıkları düzenlenebilir olmalı.*
• 1.4.13 İçerik Üzerine Fare veya Klavye: Etkileşimli içerikler net olmalı.

2. İşletilebilirlik

İçerik ve arayüz, her kullanıcı tarafından işletilebilir olmalıdır.

2.1 Klavye Erişilebilirliği

• 2.1.1 Klavye: Tüm işlevler klavye ile kullanılabilir olmalı.
• 2.1.2 Klavye Kapatılabilirliği: Klavye tuşları bir tuşa sıkışmaz.
• 2.1.4 Kısayollar: Tek tuşlu kısayollar devre dışı bırakılabilir.

2.2 Zaman Sınırları

• 2.2.1 Ayarlanabilir Zaman: Kullanıcılar zaman sınırlamalarını ayarlayabilmeli.
• 2.2.2 Duraklat, Dur veya Gizle: Otomatik olarak başlayan içerik durdurulabilir.

2.3 Nöbetler ve Fiziksel Tepkiler

• 2.3.1 Üç Flaş veya Daha Az: Flaş içerikleri sınırlanmalı.

2.4 Navigasyon

• 2.4.1 Atlama Bağlantıları: İçeriğe hızlı erişim sağlanmalı.*
• 2.4.2 Sayfa Başlıkları: Anlamlı başlıklar kullanılmalı.
• 2.4.3 Odak Sırası: Mantıklı bir odak sırası olmalı.
• 2.4.4 Bağlantılar Amaç: Bağlantı amacı açık olmalı.
• 2.4.7 Odak Görünürlüğü: Odaklanan öğeler net görünür olmalı.

Yeni Başarı Ölçütleri

• 2.4.11 Odak Görünürlüğü (2.2 ile gelen): Klavye odak göstergesi görünür olmalı.

3. Anlaşılabilirlik

Bilgi ve arayüzler, kullanıcıların anlaması için net olmalıdır.

3.1 Okunabilirlik

• 3.1.1 Dil Tanımlama: Sayfa dili belirtilmeli.*
• 3.1.2 Kısmi Dil Tanımlama: İçerikteki dil değişiklikleri belirtilmeli.

3.2 Tahmin Edilebilirlik

• 3.2.1 Odaklandığında: Bileşenler odaklanınca beklenmeyen şeyler olmamalı.
• 3.2.2 Girdi Yapıldığında: Girdi yapmak beklenmeyen değişikliklere yol açmamalı.

3.3 Girdi Yardımı

• 3.3.1 Hata Belirleme: Hatalar kullanıcıya belirtilmeli.*
• 3.3.3 Hata Önerisi: Kullanıcı hataları için öneriler sunulmalı.
• 3.3.7 Kullanıcı Yardımı (2.2 ile gelen): Girdi alanları için yardım sağlanmalı.

4. Sağlamlık

İçerik, farklı teknolojiler ve cihazlarla uyumlu olmalıdır.

4.1 Uyumlu İşaretleme

• 4.1.1 Ayrıştırma: Kod hataları giderilmeli.
• 4.1.2 İsim, Rol, Değer: Tüm öğeler için etiket ve değerler doğru atanmalı.*

Yeni Başarı Ölçütleri

• 4.1.3 Yardımcı Teknoloji Uyumluluğu (2.2 ile gelen): Yeni teknolojiler için uyum testleri yapılmalı.

Bu konuyu daha iyi öğrenmek isteyenler W3C ve ISO’nun ilgili belgelerini okumalıdırlar. İyi görmeyenler için siyah zemin üzerinde beyaz yazı (koyu tema / dark mode) kullanın. İyi görmeyenlerin sayfaları zoom yaptıklarını yani yakınlaştırma yaptıklarını unutmayın. Zoom yapıldığında siteniz ya de uygulamanızın buna uyum sağlaması gerekir.

Görme engelliler üye olurken ve oturum açarken görenlere göre daha fazla zorlandıkları için bu işlemleri mümkün olduğunca basitleştirin. Uygulamanızı mutlaka ekran okuyucu programlarla test edin. İşitme engelliler için altyazılar ve işaret dilinden yararlanın. Ayrıca uygulamanızı bilişsel olarak da erişilebilir yapın. Son olarak gerektiği yerlerde “aria” özniteliklerini de kullanmanızı hatırlatırız.

Mutlu kodlamalar

Biliyorsunuz ben 5 yıldan fazladır enGrehber adında bir yapay zeka projesi üzerinde çalışmaktayım.

Bu projeyi önce .NET ve Azure ile yaptık, Web API, .NET Identity ve Azure SQL kullandık; ancak Azure’un çok yavaş ve çok pahalı olduğunu deneyimledik.

Ayrıca .NET’in yapay zeka projeleri için çok ta uygun olmadığını gördük. Yurtdışında yapay zeka projeleri için Python tercih ediliyor ve gelecekte Rust’a geçileceği konuşuluyordu. Azure’daki buglar nedeniyle Python projemizi Azure’da yayınlayamadık.

Frontendi yayınlamak için Firebase kullandık ve Firebase’den çok memnun kaldık.

Python Projelerimiz için İdeal Hosting

Python projesinin arkasında Google var. Bu nedenle Python için Google Bulutundaki App Engine’ı denedik ve Python FastAPI projemizi App Engine ile başarıyla host edebildik, üstelik ücretsiz. Eğer App Engine size yeterli gelmezse Cloud Run’da da çalışabilirsiniz.

Çözüm: Firebase ve Google Cloud

Python, Go, Rust backendleriniz; Angular ve React frontendleriniz için Google bulutu ve Firebase ücretsiz hosting, ücretsiz üyelik sistemi, bildirim sistemi, ücretsiz veritabanı desteği ve daha fazlasını sağlıyor.

Eğer limitleri aşar ve ücretliye geçerseniz ayda 1 dolar ila 20 dolara yakın maliyet çıkabilir. Bu maliyet kullanım arttıkça artabilir, ama KOBİ’ler için ayda 1 dolar civarı temel maliyet çıkacaktır. Bir sanal asistan backendi için performansın da iyi olduğunu gözlemledik.

Kurulumları panellerden ve yüklemeleri ise bilgisayarınıza yükleyeceğiniz Firebase araçları GCloud SDK’sı ile yapabilirsiniz.

Özetle KOBİ’lerin WordPress websiteleri için Godaddy, Python backendleri için Google Cloud App Engine ya da Cloud Run; frontendler için Firebase kullanmanızı öneriyorum. Tüm eğitim kurumlarına ve okullara tavsiye ederim.

Mutlu kodlamalar

Robot Robini: Geleceğin Hizmet Robotu

Teknolojinin hızla ilerlemesiyle birlikte, günlük yaşamımızı kolaylaştıran yenilikçi çözümler hayatımıza girmeye devam ediyor. Bu çözümlerden biri de Robot Robini. Adını duyurmaya başlayan bu akıllı robot, geleceğin hizmet robotları arasında önemli bir yer edinmeye aday. İşte Robot Robini’nin öne çıkan özellikleri ve onunla ilgili bilmeniz gerekenler.

Robot Robini Nedir?

Robot Robini, evlerde, ofislerde ve diğer yaşam alanlarında insanlara yardımcı olmak için tasarlanmış, son teknoloji bir hizmet robotudur. Sahip olduğu yapay zeka sayesinde, kullanıcısının ihtiyaçlarını anlayabilen ve ona göre hareket edebilen Robini, aynı zamanda öğrenme yeteneğine de sahiptir. Yani, zamanla kullanıcısının tercihlerini ve alışkanlıklarını öğrenerek, daha kişiselleştirilmiş bir deneyim sunar.

Temel Özellikler

• Yapay Zeka ve Öğrenme Yeteneği: Robini, yapay zeka algoritmaları sayesinde çevresindeki olayları analiz edebilir ve duruma göre hareket edebilir. Ayrıca, kullanıcıların komutlarını zamanla daha iyi anlar ve onlara uygun çözümler üretir.
• Çok Yönlülük: Robini, birden fazla görevi yerine getirebilecek şekilde tasarlanmıştır. Evinizi temizlemekten tutun da, yiyecek-içecek servisine kadar pek çok farklı görevi başarıyla yerine getirebilir. Ayrıca, güvenlik sistemlerine entegre edilerek evinizi izleyebilir ve güvenlik tehditlerine karşı alarm verebilir.
• Sesli ve Görsel İletişim: Kullanıcılarıyla etkili bir şekilde iletişim kurabilen Robini, hem sesli hem de görsel komutları algılayabilir. Gelişmiş mikrofonları ve kameraları sayesinde çevresindeki sesleri ve görüntüleri analiz edebilir.
• Mobilite: Robot Robini, hareket kabiliyeti açısından da oldukça gelişmiştir. Dar alanlarda manevra yapabilme yeteneğine sahip olan bu robot, merdiven çıkma, engellerden kaçınma gibi becerileri ile dikkat çeker.

Kullanım Alanları

Robot Robini, çok geniş bir yelpazede kullanım alanı bulmaktadır. Evlerde günlük işlerinizi kolaylaştırırken, ofislerde de çeşitli görevleri üstlenebilir. Ayrıca, otellerde müşteri hizmetlerini geliştirmek için kullanılabilir. Gelişmiş sensörleri ve yapay zeka özellikleri sayesinde, hastanelerde hasta bakımı gibi daha özel görevlerde de yer alabilir.

Geleceğin Hizmet Robotu

Robot Robini, teknoloji dünyasında hızla ilerleyen yapay zeka ve robotik alanlarının bir meyvesi olarak karşımıza çıkıyor. Onunla birlikte, gelecekte robotların hayatımızın vazgeçilmez bir parçası haline geleceğini söylemek yanlış olmaz. Robot Robini, sadece bir başlangıç ve önümüzdeki yıllarda bu tür robotların sayısında ve işlevselliğinde büyük bir artış bekleniyor.

Sonuç olarak, Robot Robini, hayatımızı kolaylaştırma potansiyeli yüksek olan, yenilikçi bir hizmet robotu olarak dikkat çekiyor. İleri teknolojiye sahip bu robot, özellikle yoğun yaşam temposuna sahip bireyler ve işletmeler için ideal bir çözüm sunuyor. Gelecekte, Robot Robini’nin sunduğu imkanlar sayesinde, gündelik işlerimize daha az zaman ayırıp, sevdiklerimize ve hobilerimize daha fazla vakit ayırabileceğiz.

Mutluluklar

OpenAI’nin Strawberry Projesi

OpenAI’nin Project Strawberry’si, AI modellerinin muhakeme yeteneklerini geliştirmeye odaklanıyor. Sızdırılan dahili belgelere göre, bu proje karmaşık muhakeme görevlerini yüksek doğrulukla gerçekleştirebilen modeller oluşturmayı amaçlıyor. Project Strawberry kapsamında geliştirilen yeni model türü, matematiksel görevlerde olağanüstü performans göstererek, mevcut LLM’lerin şans seviyelerinde performans gösterdiği kıyaslamalarda %90 doğruluk elde etti.

Project Strawberry’nin temel yeniliği, daha büyük modellerin düşüncelerini doğrulamak veya onaylamak için gerçek zamanlı olarak daha küçük modeller kullanmayı içerir. Bu yaklaşım, AI’nın çözümleri daha etkili bir şekilde aramasını sağlar ve AI’daki gerçek hendek olabilecek şeyin ne olduğuna dair net bir görüş sağlar: muhakeme. Bu gelişme, mevcut LLM’lerin meta haline gelmesini ele aldığı ve muhakeme yeteneklerinde önemli bir sıçrama sunmayı hedeflediği için OpenAI için çok önemlidir.

Google’ın Milyon Uzman LLM’i

Öte yandan, Google’ın Milyon Uzman LLM’i, Parametre Verimli Uzman Alma (PEER) adı verilen yeni bir yöntem sunar. Bu yöntem, LLM’i her biri girdi verilerinin farklı yönlerinde uzmanlaşmış bir milyon uzmana böler. Model, girdi ve uzmanlar arasında bir alma yöntemi olarak çapraz dikkat kullanır ve bu da verilen herhangi bir girdi için en yetenekli uzmanları seçmesine olanak tanır.
.
PEER katmanı, hesaplama yükünü azaltarak ve çıktının kalitesini iyileştirerek modelin verimliliğini önemli ölçüde artırır. En ilgili uzmanlardan bilgi alarak ve gömerek, model daha doğru ve bağlamsal olarak uygun yanıtlar sağlayabilir. Bu yaklaşım yalnızca hesaplama performansını iyileştirmekle kalmaz, aynı zamanda model kalitesini değerlendirmek için önemli bir ölçüt olan şaşkınlığı da azaltır.

Verimlilik ve Performans Kazanımları

Hem OpenAI’nin Project Strawberry’si hem de Google’ın Million-Expert LLM’i önemli verimlilik kazanımları sunar. Project Strawberry’nin muhakeme ve doğrulamaya odaklanması, yüksek düzeyde bilişsel işleme gerektiren görevler için çok önemli olan daha doğru ve güvenilir AI çıktıları sağlar. Bu arada, Google’ın PEER yöntemi, geniş bir uzman uzman ağından yararlanarak LLM’lerin ölçeklenebilirliğini ve verimliliğini artırır ve daha düşük hesaplama maliyetiyle daha iyi performansa yol açar.

Bu gelişmeler, AI araştırmalarında daha verimli ve yetenekli modellere doğru önemli bir kaymayı vurgular. Mevcut LLM’lerin sınırlamalarını ele alarak ve muhakeme ve uzman geri çağırma için yenilikçi yöntemler sunarak, OpenAI ve Google yapay zeka alanında yeni ölçütler belirliyor.

Mutlu kodlamalar

Sizler için Cumhurbaşkanlığının yayınlandığı Ulusal Yapay Zeka Stratejisi dokümanını hızlıca okudum. Kısa bir özetini yayınlamak istiyorum.

Birinci hedef anonim ve gizli veri kümeleri oluşturmaktır deniliyor. Şahsen bu işle uğraştığım için yakından biliyorum: Bazı alanlarda Türkçe “corpus” bulmak gerçekten zor. Tüm mevzuatın kaliteli ve güncellenen bir veri kümesine dönüştürülmesi gibi önümüzde hayli önemli bir iş var. Bizim web sitelerimizden içerik çekmek ve arama yapmak Wikipedia gibi sitelerle karşılaştırıldığında bir hayli zor.

Ayrıca basın-yayın, kitaplar, ansiklopediler, tüm sektörler ve tarihimiz için de güncellenen veri kümeleri üretmemiz gerekiyor. Şu an bir yapay zeka geliştirseniz mecburen Vikipedi gibi yurtdışı projelerine başvurmak zorunda kalıyorsunuz.

Türkiye ve dünya web arşivinin (kapanan sitelerdeki içerikler dahil) de bir veri kümesine dönüştürülmesi güzel olur.

Aslında ben bu dokümana şöyle bir ekleme yapmak isterdim. Türkiye’de popüler bir sosyal medya sitemiz olmadığı için mevcut Twitter, Instagram, LinkedIn, Facebook, Youtube vb. sitelerle anlaşmalar yaparak geçmiş ve güncel sosyal medya içeriğine erişim sağlamalıyız ki Grok benzeri sosyal medya beslemeli yapay zeka üretebilelim.

Aksi taktirde ürettiğimiz hiçbir yapay zeka sosyal medya beslemeli olamayacak ve bu konuda yurtdışına bağımlı kalacağız demektir. Bu sorun diğer ülkelerde de var, bu yüzden mevcut popüler sosyal medya siteleriyle anlaşmalar yapmanın denenmesi lazım kanaatindeyim.

Yapay zeka konusunda Türkçe, Osmanlıca vb. dil bilgisi ve çeviri alanlarında uzmanlaşmış açık kaynak kodlu kütüphanelere de ihtiyaç var. Türkçe İşaret Dili de dahil olmak üzere bu alandaki kullanıma hazır kütüphanelerin kaynak kodlarıyla birlikte geliştiricilere sunulması gerekiyor.

Türkiye’deki geliştiricilerin ek iş olarak yerli open source projelere katılımının teşvik edilmesi güzel olur. Yani iş dünyası iş görüşmelerinde bunu bir artı olarak değerlendirirse geliştiriciler de avantajlı olduğu için bu alana yöneleceklerdir.

Ulusal Yapay Zeka Stratejisi Dokümanını buradan indirebilirsiniz.

Ulusal Yapay Zeka Stratejisi 2024-2025 Eylem Planı

Mutlu kodlamalar

2024 yılında Yapay Zeka eğitimi verenlerin eğitime nereden başlamaları, neleri öğretmeleri ve nasıl devam etmeleri gerektiği üzerine bir makale yazmaya karar verdim. Bu makalede önce kod-sonra teori yaklaşımı uygulanmaktadır.

Özel ve gizli gizli öğrenim yerine halka açık öğrenmenizi tavsiye ediyorum. Yani blogunuzda makaleler yazarak öğrenin, insanlarla konuşarak öğrenin, Discord topluluklarına sorular sorarak öğrenin, herkese açık bir proje yazarak öğrenin, tweet atarak öğrenin.

Müfredat

1. Matematik
2. Araçlar
   • Python
   • Pytorch
3. Makine Öğrenmesi
   • Sıfırdan Yaz
   • Rekabet
   • Yan Projeler Yap
   • Onları Yayınla
   • Tamamlayıcı
4. Derin Öğrenme
   • Fast.ai
   • Rekabette Daha Fazlasını Yap
   • Sayfaları Uygula
   • Bilgisayar Görmesi (Computer Vision)
   • Doğal Dil İşleme (NLP)
5. Geniş Dil Modelleri (LLM)
   • Sinir Ağlarını İzle
   • Ücretsiz LLM Eğitim Kampı
   • LLM’lerle Yapın
   • Hackathon’lara Katılın
   • Sayfaları Okuyun
   • Sıfırdan Transformatörler Yazın
   • Bazı İyi Blog’lar
   • Umar Jamil’i İzleyin
   • Açık Kaynaklı Modelleri Çalıştırmayı Öğrenin
   • Prompt Mühendisliği
   • LLM’leri Fine-tune Edin
   • RAG
6. Nasıl Güncel Kalınır?

Bu makalenin orjinal İngilizce sürümünde müfredat başlıklarının içeriği hakkında daha ayrıntılı bilgi bulunmaktadır. Orjinal makale için: https://medium.com/bitgrit-data-science-publication/a-roadmap-to-learn-ai-in-2024-cc30c6aa6e16

Mutlu kodlamalar

1. Abstraction / Soyutlama
2. Encapsulation / Kapsülleme
3. DRY (Don’t repeat yourself, aka DIE: duplication is evil)
4. KISS (Keep it simple, stupid)
5. YAGNI (You aren’t gonna need it)
6. LoD (Law of Demeter)
7. SoC (Separation of Concerns)
   
8. SOLID
   • Single Responsibility (“A class should have one, and only one, reason to change.”)
   • Open-closed principle (“Software entities should be open for extension but closed for modification.”)
   • Liskov substitution (“Derived classes must be substitutable for their base classes.”)
   • Interface segregation (“Make fine-grained interfaces that are client-specific.”)
   • Dependency inversion (“Depend on abstractions, not on concretions.”)
     
9. GRASP (General Responsibility Assignment Principles)
   • High cohesion (“Keep related functionalities and responsibilities together.”)
   • Low coupling (“Reduce relations between unstable elements.”)
   • Information expert (“Place responsibilities with data.”)
   • Creator (“Assign the responsibility for object creation to a closely related class.”)
   • Controller (“Assing the responsibility for handling system messages to a specific class.”)
   • Indirection (“To support a low coupling, assign the responsibility to an intermediate class.”)
   • Polymorphism (“When related alternative behaviors vary by type, use polymorphism to assign responsibility to the types for which the behavior varies.”)
   • Pure fabrication (“To support a high cohesion, assign the responsibility to the convenient class.”)
   • Protected variations (“Protect predicted variations by introducing a stable contract.”)

Sonuç

Bu makalede yazılım geliştirme ilkelerinin listesi özetlenerek sizlere sunulmuştur. Özgün makaleyi okumak isteyenler aşağıdaki bağlantıya tıklayabilirler ki özgün makalede konu detaylarıyla birlikte anlatılmaktadır:
https://medium.com/gitconnected/the-20-essential-principles-of-software-development-lod-soc-solid-and-beyond-7a39a98b685d

Makalemizde aşağıdakilerin nasıl yapıldığını öğreneceksiniz:

• .proto dosyasında bir servis tanımlamak
• Servisimiz için Node.js gRPC API kullanarak basit bir istemci ve sunucu yazmak

gRPC’ye Giriş

Bu bölüm sizleri gRPC ve Protokol Arabellekleri (protocol buffers) hakkında bilgilendirecektir. gRPC, protokol arabelleklerini hem Arayüz Tanımı Dili (Interface Definition Language – IDL) ve hem de temel mesaj değişim formatı olarak kullanabilir.

Genel Bakış

gRPC içinde, bir istemci uygulaması, farklı bir makinedeki sunucu uygulaması üzerindeki bir metodu yerel bir nesnede olduğu gibi doğrudan çağırabilir, ki böylece dağıtık uygulama ve hizmetleri oluşturmayı kolaylaştırır. Çoğu RPC sistemlerinde olduğu gibi, gRPC, servisi tanımlama, uzaktan çağrılabilecek metotları ve dönüş tiplerini belirtme üzerine temellenmiştir. Sunucu tarafında, sunucu, arayüzü implemente eder ve istemci taleplerini yönetmek için bir gRPC sunucusu çalıştırır. İstemci tarafında ise, istemcinin bir stub’ı (istemcide hangi programlama dilini kullanıyorsanız o dilde) vardır ki sunucudakinin aynı metotlarını sağlar.

gPRC istemcileri ve sunucuları birbirleriyle farklı ortamlarda konuşabilir ve çalışabilirler ve gRPC’yi destekleyen dillerle yazılabilirler.

Protokol Arabellekleri ile Çalışmak

Varsayılan olarak, gRPC, Protokol Arabelleklerini kullanır. Protokol Arabellekleri, yapılandırılmış veriyi serileştirmek için Google’ın açık kaynak kodlu mekanizmasıdır. Aşağıda nasıl çalıştığıyla ilgili küçük bir örnek bulacaksınız.

Protokol Arabellekleri ile çalışırken ilk adım bir proto dosyasında verinin yapısını tanımlamaktır. Proto dosyası .proto uzantılı sıradan bir metin dosyasıdır. Protokol arabelleği verisi, mesajlar olarak yapılandırılmıştır ve her bir mesaj “alanlar” denilen ad-değer çiftleri serisini içeren küçük mantıksal kayıt bilgileridir. İşte küçük bir örnek:

message Person {
  string name = 1;
  int32 id = 2;
  bool has_ponycopter = 3;
}

Veri yapılarını tanımladıktan sonra protokol arabelleği derleyicisi olan “protoc” ile tercih ettiğiniz dilde proto tanımınızdan veri erişim sınıflarını üretirsiniz. Böylece her bir alan için basit erişim metotları elde edersiniz, örneğin name() ve set_name() gibi; ve aynı zamanda tüm yapıyı salt baytlara serileştirmek/parse etmek ve salt baytlardan nesnelere çevirmek için gerekli metotları elde edersiniz. Böylece örneğin seçtiğiniz dil Node.js ise, derleyiciyi çalıştırdığınızda “Person” denilen bir sınıf üretirsiniz. Bu sınıfı uygulamanızda içini doldurmak, serileştirmek ve “Person” protokol arayüz mesajları almak için kullanabilirsiniz.

Mesajları gördük. gRPC servislerini ise sıradan proto dosyalarında RPC metot parametreleri ve dönüş tipleri ile tanımlarsınız.

// The greeter service definition.
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// The request message containing the user's name.
message HelloRequest {
  string name = 1;
}

// The response message containing the greetings
message HelloReply {
  string message = 1;
}

gRPC, protokol dosyanızdan kod oluşturmak için özel bir gRPC eklentisiyle protoc kullanır: oluşturulan gRPC istemci ve sunucu kodunun yanı sıra mesaj türlerinizi doldurmak, serileştirmek ve almak için normal protokol arabellek kodunu alırsınız.

Niçin gPRC Kullanıyoruz?

Örneğimiz, istemcilerin rotalarındaki özellikler hakkında bilgi almasına, rotalarının bir özetini oluşturmasına ve sunucu ve diğer istemcilerle trafik güncellemeleri gibi rota bilgileri alışverişinde bulunmasına olanak tanıyan basit bir rota haritalama uygulamasıdır.

GRPC ile hizmetimizi bir kez bir .proto dosyasında tanımlayabilir ve gRPC’nin desteklediği dillerden herhangi birinde istemciler ve sunucular oluşturabiliriz; bunlar da büyük bir veri merkezi içindeki sunuculardan kendi tabletinize kadar çeşitli ortamlarda çalıştırılabilir – tüm karmaşıklık Farklı diller ve ortamlar arasındaki iletişim sizin için gRPC tarafından gerçekleştirilir. Ayrıca verimli serileştirme, basit bir IDL ve kolay arayüz güncellemesi de dahil olmak üzere protokol arabellekleriyle çalışmanın tüm avantajlarından yararlanıyoruz.

Örnek Kod ve Kurulum

Eğitimimizin örnek kodu grpc/grpc-node/examples/routeguide/dynamic_codegen konumundadır. Depoya baktığınızda göreceğiniz gibi, grpc/grpc-node/examples/routeguide/static_codegen‘de de çok benzer görünen bir örnek var. RouteGuide örneğimizin iki versiyonu var çünkü Node.js’de protokol arabellekleriyle çalışmak için gereken kodu oluşturmanın iki yolu var; bir yaklaşım, çalışma zamanında kodu dinamik olarak oluşturmak için Protobuf.js’yi kullanıyor, diğeri ise statik olarak oluşturulan kodu kullanıyor. Örnekler aynı şekilde davranır ve her iki sunucu da her iki istemciyle de kullanılabilir. Dizin adından da anlaşılacağı gibi, bu belgede dinamik olarak oluşturulmuş kod içeren sürümü kullanacağız, ancak statik kod örneğine de bakmaktan çekinmeyin.

Örneği indirmek için aşağıdaki komutu çalıştırarak grpc deposunu kopyalayın:

$ git clone -b @grpc/grpc-js@1.9.0 --depth 1 --shallow-submodules https://github.com/grpc/grpc-node
$ cd grpc

Ve şu anki dizini examples olarak değiştirin:

$ cd examples

Proto Dosyası

İlk adımımız protokol arabelleklerini kullanarak gRPC servisini ve metot isteği ve yanıt türlerini, ve mesajları tanımlamaktır. .proto dosyasının tamamını example/protos/route_guide.proto‘da görebilirsiniz.

syntax = "proto3";

package routeguide;

// Interface exported by the server.
service RouteGuide {
  // A simple RPC.
  //
  // Obtains the feature at a given position.
  //
  // A feature with an empty name is returned if there's no feature at the given
  // position.
  rpc GetFeature(Point) returns (Feature) {}

  // A server-to-client streaming RPC.
  //
  // Obtains the Features available within the given Rectangle.  Results are
  // streamed rather than returned at once (e.g. in a response message with a
  // repeated field), as the rectangle may cover a large area and contain a
  // huge number of features.
  rpc ListFeatures(Rectangle) returns (stream Feature) {}

  // A client-to-server streaming RPC.
  //
  // Accepts a stream of Points on a route being traversed, returning a
  // RouteSummary when traversal is completed.
  rpc RecordRoute(stream Point) returns (RouteSummary) {}

  // A Bidirectional streaming RPC.
  //
  // Accepts a stream of RouteNotes sent while a route is being traversed,
  // while receiving other RouteNotes (e.g. from other users).
  rpc RouteChat(stream RouteNote) returns (stream RouteNote) {}
}

// Points are represented as latitude-longitude pairs in the E7 representation
// (degrees multiplied by 10**7 and rounded to the nearest integer).
// Latitudes should be in the range +/- 90 degrees and longitude should be in
// the range +/- 180 degrees (inclusive).
message Point {
  int32 latitude = 1;
  int32 longitude = 2;
}

// A latitude-longitude rectangle, represented as two diagonally opposite
// points "lo" and "hi".
message Rectangle {
  // One corner of the rectangle.
  Point lo = 1;

  // The other corner of the rectangle.
  Point hi = 2;
}

// A feature names something at a given point.
//
// If a feature could not be named, the name is empty.
message Feature {
  // The name of the feature.
  string name = 1;

  // The point where the feature is detected.
  Point location = 2;
}

// A RouteNote is a message sent while at a given point.
message RouteNote {
  // The location from which the message is sent.
  Point location = 1;

  // The message to be sent.
  string message = 2;
}

// A RouteSummary is received in response to a RecordRoute rpc.
//
// It contains the number of individual points received, the number of
// detected features, and the total distance covered as the cumulative sum of
// the distance between each point.
message RouteSummary {
  // The number of points received.
  int32 point_count = 1;

  // The number of known features passed while traversing the route.
  int32 feature_count = 2;

  // The distance covered in metres.
  int32 distance = 3;

  // The duration of the traversal in seconds.
  int32 elapsed_time = 4;
}

Servis tanımlayıcılarını protokol dosyalarından yükleme

Node.js kitaplığı, çalışma zamanında yüklenen .proto dosyalarından hizmet tanımlayıcılarını ve istemci stub (saplama) tanımlarını dinamik olarak oluşturur.

Bir .proto dosyasını yüklemek için, gRPC protokol yükleyici kitaplığına ihtiyaç duymanız ve bunun loadSync() yöntemini kullanmanız, ardından çıktıyı gRPC kitaplığının loadPackageDefinition yöntemine aktarmanız yeterlidir:

var PROTO_PATH = __dirname + '/../../protos/route_guide.proto';
var grpc = require('@grpc/grpc-js');
var protoLoader = require('@grpc/proto-loader');
// Suggested options for similarity to existing grpc.load behavior
var packageDefinition = protoLoader.loadSync(
    PROTO_PATH,
    {keepCase: true,
     longs: String,
     enums: String,
     defaults: true,
     oneofs: true
    });
var protoDescriptor = grpc.loadPackageDefinition(packageDefinition);
// The protoDescriptor object has the full package hierarchy
var routeguide = protoDescriptor.routeguide;

Bunu yaptıktan sonra, stub yapıcısı routeguide ad alanındadır (protoDescriptor.routeguide.RouteGuide) ve hizmet tanımlayıcısı (sunucu oluşturmak için kullanılır) stub’ın bir özelliğidir (protoDescriptor.routeguide.RouteGuide.service).

Sunucuyu oluşturma

Öncelikle RouteGuide sunucusunu nasıl oluşturduğumuza bakalım. Yalnızca gRPC istemcileri oluşturmakla ilgileniyorsanız, bu bölümü atlayabilir ve doğrudan İstemci oluşturma bölümüne gidebilirsiniz (yine de bunu ilginç bulabilirsiniz!).

RouteGuide hizmetimizin işini yapmasını sağlamanın iki bölümü vardır:

Hizmet tanımımızdan oluşturulan hizmet arayüzünü uygulamak: hizmetimizin asıl “işini” yapmak.
İstemcilerden gelen istekleri dinlemek ve hizmet yanıtlarını döndürmek için bir gRPC sunucusu çalıştırma.
Örnek RouteGuide sunucumuzu example/routeguide/dynamic_codegen/route_guide_server.js adresinde bulabilirsiniz. Nasıl çalıştığına daha yakından bakalım.

RouteGuide’ı Uygulama

Gördüğünüz gibi sunucumuz RouteGuide.service tanımlayıcı nesnesinden oluşturulmuş bir server yapıcısına sahiptir.

var Server = new grpc.Server();

Bu durumda, varsayılan gRPC sunucu davranışımızı sağlayan RouteGuide’ın asenkron sürümünü uyguluyoruz.

Route_guide_server.js’deki işlevler tüm hizmet yöntemlerimizi uygular. Önce en basit tür olan getFeature’a bakalım; bu, istemciden yalnızca bir Point alır ve karşılık gelen özellik bilgisini veritabanından bir Feature içinde döndürür.

function checkFeature(point) {
  var feature;
  // Check if there is already a feature object for the given point
  for (var i = 0; i < feature_list.length; i++) {
    feature = feature_list[i];
    if (feature.location.latitude === point.latitude &&
        feature.location.longitude === point.longitude) {
      return feature;
    }
  }
  var name = '';
  feature = {
    name: name,
    location: point
  };
  return feature;
}
function getFeature(call, callback) {
  callback(null, checkFeature(call.request));
}

Yöntem, RPC için özellik olarak Point parametresine sahip olan bir çağrı nesnesine ve döndürülen Feature’ımızı iletebileceğimiz bir geri çağrıya iletilir. Yöntem gövdesinde, verilen noktaya karşılık gelen bir Feature’ı doldururuz ve onu, hiçbir hata olmadığını belirtmek için boş bir ilk parametreyle geri çağırmaya geçiririz.

Şimdi biraz daha karmaşık bir şeye bakalım: akışlı bir RPC. listFeatures, sunucu tarafı akışlı bir RPC’dir, bu nedenle istemcimize birden fazla Feature göndermemiz gerekir.

function listFeatures(call) {
  var lo = call.request.lo;
  var hi = call.request.hi;
  var left = _.min([lo.longitude, hi.longitude]);
  var right = _.max([lo.longitude, hi.longitude]);
  var top = _.max([lo.latitude, hi.latitude]);
  var bottom = _.min([lo.latitude, hi.latitude]);
  // For each feature, check if it is in the given bounding box
  _.each(feature_list, function(feature) {
    if (feature.name === '') {
      return;
    }
    if (feature.location.longitude >= left &&
        feature.location.longitude <= right &&
        feature.location.latitude >= bottom &&
        feature.location.latitude <= top) {
      call.write(feature);
    }
  });
  call.end();
}

Gördüğünüz gibi metod parametrelerimizde call nesnesini ve callback’i almak yerine bu sefer Writable arayüzü uygulayan bir call nesnesi alıyoruz. Yöntemde, döndürmemiz gereken sayıda Feature nesnesi oluştururuz ve bunları write() yöntemini kullanarak call’a yazarız. Son olarak tüm mesajları gönderdiğimizi belirtmek için call.end() metodunu çağırıyoruz.

İstemci tarafı akış yöntemi RecordRoute’a bakarsanız, bunun tekli call’a oldukça benzer olduğunu görürsünüz, ancak bu sefer call parametresi Reader arayüzünü uygular. Call’un ‘data’ olayı her yeni veri olduğunda tetiklenir ve ‘end’ olayı tüm veriler okunduğunda tetiklenir. Tekli durumda olduğu gibi, callback’i çağırarak yanıt veririz.

call.on('data', function(point) {
  // Process user data
});
call.on('end', function() {
  callback(null, result);
});

Son olarak çift yönlü akış RPC RouteChat()’a bakalım:

function routeChat(call) {
  call.on('data', function(note) {
    var key = pointKey(note.location);
    /* For each note sent, respond with all previous notes that correspond to
     * the same point */
    if (route_notes.hasOwnProperty(key)) {
      _.each(route_notes[key], function(note) {
        call.write(note);
      });
    } else {
      route_notes[key] = [];
    }
    // Then add the new note to the list
    route_notes[key].push(JSON.parse(JSON.stringify(note)));
  });
  call.on('end', function() {
    call.end();
  });
}

Bu sefer mesajları okumak ve yazmak için kullanılabilecek Duplex’i uygulayan bir çağrı alıyoruz. Buradaki okuma ve yazma sözdizimi, istemci akışı ve sunucu akışı yöntemlerimizle tamamen aynıdır. Her ne kadar her iki taraf da diğerinin mesajlarını her zaman yazıldığı sıraya göre alsa da, hem istemci hem de sunucu herhangi bir sırayla okuyabilir ve yazabilir; akışlar tamamen bağımsız olarak çalışır.

Sunucuyu başlatma

Tüm yöntemlerimizi uyguladıktan sonra, müşterilerin hizmetimizi gerçekten kullanabilmesi için bir gRPC sunucusu da başlatmamız gerekiyor. Aşağıdaki kod parçası RouteGuide hizmetimiz için bunu nasıl yaptığımızı göstermektedir:

function getServer() {
  var server = new grpc.Server();
  server.addService(routeguide.RouteGuide.service, {
    getFeature: getFeature,
    listFeatures: listFeatures,
    recordRoute: recordRoute,
    routeChat: routeChat
  });
  return server;
}
var routeServer = getServer();
routeServer.bindAsync('0.0.0.0:50051', grpc.ServerCredentials.createInsecure(), () => {
  routeServer.start();
});

Gördüğünüz gibi aşağıdaki adımlarla sunucumuzu kurup başlatıyoruz:

• RouteGuide hizmet tanımlayıcısından bir Sunucu yapıcısı oluşturun.
• Servis yöntemlerini uygulayın.
• Yöntem uygulamalarıyla Sunucu yapıcısını çağırarak sunucunun bir örneğini oluşturun.
• Örneğin bind() yöntemini kullanarak istemci isteklerini dinlemek için kullanmak istediğimiz adresi ve bağlantı noktasını belirtin.
• RPC sunucusunu başlatmak için örnekte start() öğesini çağırın.

İstemciyi oluşturma

Bu bölümde RouteGuide hizmetimiz için Node.js istemcisi oluşturmaya bakacağız. Örnek istemci kodumuzun tamamını example/routeguide/dynamic_codegen/route_guide_client.js adresinde görebilirsiniz.

Stub oluşturma

Servis yöntemlerini çağırmak için öncelikle bir stub oluşturmamız gerekiyor. Bunu yapmak için, sunucu adresini ve bağlantı noktasını belirterek RouteGuide stub yapıcısını çağırmamız yeterlidir.

new routeguide.RouteGuide('localhost:50051', grpc.credentials.createInsecure());

Servis yöntemlerinin çağrılması

Şimdi hizmet yöntemlerimizi nasıl adlandırdığımıza bakalım. Bu yöntemlerin hepsinin asenkron olduğunu unutmayın: sonuçları almak için olayları veya callback’leri kullanırlar.

Basit RPC

Basit RPC GetFeature’ı çağırmak neredeyse yerel asenkron (eşzamansız) bir yöntemi çağırmak kadar basittir.

var point = {latitude: 409146138, longitude: -746188906};
stub.getFeature(point, function(err, feature) {
  if (err) {
    // process error
  } else {
    // process feature
  }
});

Gördüğünüz gibi bir request nesnesi oluşturup dolduruyoruz. Son olarak, stub’taki yöntemi çağırırız, ona request ve callback’i iletiriz. Eğer hata yoksa sunucudan gelen yanıt bilgisini yanıt nesnemizden okuyabiliriz.

console.log('Found feature called "' + feature.name + '" at ' +
    feature.location.latitude/COORD_FACTOR + ', ' +
    feature.location.longitude/COORD_FACTOR);

Akış RPC’leri

Şimdi akış yöntemlerimize bakalım. Sunucu oluşturma konusunu daha önce okuduysanız bunlardan bazıları çok tanıdık gelebilir; akışlı RPC’ler her iki tarafta da benzer şekilde uygulanır. Coğrafi Feature’ların akışını döndüren sunucu tarafı akış yöntemini ListFeatures olarak adlandırdığımız yer burasıdır:

var call = client.listFeatures(rectangle);
  call.on('data', function(feature) {
      console.log('Found feature called "' + feature.name + '" at ' +
          feature.location.latitude/COORD_FACTOR + ', ' +
          feature.location.longitude/COORD_FACTOR);
  });
  call.on('end', function() {
    // The server has finished sending
  });
  call.on('error', function(e) {
    // An error has occurred and the stream has been closed.
  });
  call.on('status', function(status) {
    // process status
  });

Metoda bir request ve callback iletmek yerine, ona bir request iletiriz ve Okunabilir bir akış nesnesini geri alırız. İstemci, sunucunun yanıtlarını okumak için Okunabilir’in ‘data’ olayını kullanabilir. Bu olay, daha fazla mesaj kalmayıncaya kadar her Feature mesajı nesnesiyle birlikte tetiklenir. ‘data’ callback’indeki hatalar akışın kapatılmasına neden olmaz. ‘error’ olayı bir hatanın oluştuğunu ve akışın kapatıldığını gösterir. ‘end’ olayı, sunucunun gönderimi tamamladığını ve herhangi bir hata oluşmadığını gösterir. ‘error’ veya ‘end’ten yalnızca biri yayınlanacaktır. Son olarak, sunucu durumu gönderdiğinde ‘status’ olayı tetiklenir.

İstemci tarafı akış metodu RecordRoute benzerdir; tek fark, metoda bir callback iletmemiz ve bir Yazılabilir’i geri almamızdır.

var call = client.recordRoute(function(error, stats) {
  if (error) {
    callback(error);
  }
  console.log('Finished trip with', stats.point_count, 'points');
  console.log('Passed', stats.feature_count, 'features');
  console.log('Travelled', stats.distance, 'meters');
  console.log('It took', stats.elapsed_time, 'seconds');
});
function pointSender(lat, lng) {
  return function(callback) {
    console.log('Visiting point ' + lat/COORD_FACTOR + ', ' +
        lng/COORD_FACTOR);
    call.write({
      latitude: lat,
      longitude: lng
    });
    _.delay(callback, _.random(500, 1500));
  };
}
var point_senders = [];
for (var i = 0; i < num_points; i++) {
  var rand_point = feature_list[_.random(0, feature_list.length - 1)];
  point_senders[i] = pointSender(rand_point.location.latitude,
                                 rand_point.location.longitude);
}
async.series(point_senders, function() {
  call.end();
});

Write() kullanarak müşterimizin isteklerini akışa yazmayı bitirdikten sonra, gRPC’ye yazmayı bitirdiğimizi bildirmek için akışta end() öğesini çağırmamız gerekir. Durum iyiyse stats nesnesi sunucunun yanıtıyla doldurulacaktır.

Son olarak çift yönlü akış RPC RouteChat()’a bakalım. Bu durumda, metoda yalnızca bir bağlam aktarırız ve mesajları hem yazmak hem de okumak için kullanabileceğimiz bir Duplex akış nesnesini geri alırız.

var call = client.routeChat();

Buradaki okuma ve yazma sözdizimi, istemci akışı ve sunucu akışı yöntemlerimizle tamamen aynıdır. Her iki taraf da diğerinin mesajlarını her zaman yazıldığı sıraya göre alsa da, hem istemci hem de sunucu herhangi bir sırayla okuyabilir ve yazabilir; akışlar tamamen bağımsız olarak çalışır.

Mutlu kodlamalar

Uzun bir aradan sonra Medium makalelerini takip ettikçe yazılımın geleceği üzerine daha iyi bir görüş kazandığıma inanıyorum.

Buna göre C ve C++’tan kurtulamamış programlama dilleri Siber Güvenlik kriterlerini karşılamada oldukça zor durumdalar. Python komple C ile yazılmış durumda, her ne kadar popüler de olsa bellek güvenliği konusunda hiç iyi durumda değil. Java ve .NET dillerinin OpenJDK ve .NET Runtime’larının kaynak kodlarını incelediğimizde büyük oranda C ve C++ kodları içerdiğini görmekteyiz. O yüzden bu diller de bellek güvenliği konusunda geride kalmış durumdalar, ancak Microsoft bellek güvenliği konusunda çalışma yapacaklarını açıkladı.

Bellek güvenliği ve performansta en önde ve en iyi olan diller Rust ve Go dilleridir. Ancak bunlar da halen C Runtime’ına bağımlıdırlar, buna karşın bu dillerin her ikisi de C’den bağımsız hale getirilebiliyorlar. Kaynak kodları zaten C ve C++’tan arındırılmıştır ve runtime’da da tamamen arındırıp saf Rust ve saf Go çıktısı alınabiliyor.

Öte taraftan Devin AI ile farkettik ki Web 2.0 yazılımlarını artık WordPress’e benzeyen araçlarla hazır temalı arayüzlerle bir kaç dakikada hazırlayabiliyoruz. O yüzden artık Web 2.0 yazılımları hazırlamak kolay ve ucuz bir iş haline dönüşmeye başlıyor.

Ancak buna karşın BlockChain yazılımları hazırlamak halen çok zor kabul ediliyor. Rusya’nın Ethereum’u Go’yu ve Solidity’i tercih etmiş durumda. Elon Musk ve Mark Zuckerberg ise BlockChain ve Yapay Zeka’da Rust’ı tercih etmiş durumdalar. NodeJS ise performansta oldukça geride kalmış bir teknoloji olduğu için ben tavsiye etmiyorum, eğer EVM (Ethereum Virtual Machine) yerine NodeJS tercih edilirse görüşüm değişebilir.

O yüzden yazılımcıların aşağıdaki teknolojileri öğrenmelerini tavsiye ediyorum:

1. Rust: bellek güvenliği ve performansta en iyisidir ve C’den tamamen bağımsız hale getirilebiliyor.
2. Go: bellek güvenliği ve performansta oldukça iyidir ve C’den tamamen bağımsız hale getirilebiliyor.
3. AI
4. BlockChain

Şimdi bu makalede PoS algoritmasını kullanarak Rust ile bir blockchain geliştirelim…

Genel Rehber

Rust ile bir PoS (Proof of Stake) blockchain ağı oluşturmak oldukça ilginç bir projedir. İşte bu projeyi gerçekleştirmek için genel bir rehber:

1. Gerekli Araçların Kurulumu:
   • Rust programlama dili ve Cargo paket yöneticisi gibi geliştirme araçlarını kurmanız gerekecek. Rust’un resmi web sitesinden indirip kurabilirsiniz.
2. Proje Yapısının Oluşturulması:
   • Boş bir proje dizini oluşturun ve içine giriş noktası olan main.rs dosyasını ekleyin.
   • Projeyi başlatmak için bir Cargo.toml dosyası oluşturun. Bu dosyada proje bağımlılıklarını ve diğer yapılandırma ayarlarını tanımlayabilirsiniz.
3. Blockchain Temel Yapısının Oluşturulması:
   • Blok, zincir ve diğer temel yapıları temsil etmek için Rust’ta bir dizi veri yapısı tanımlayın. Örneğin, Block ve Blockchain yapılarını tanımlayabilirsiniz.
   • Blokların içeriğini, önceki bloğun hash’ini, kendi hash’ini ve diğer gerekli bilgileri içerecek şekilde tanımlayın.
4. PoS Algoritmasının Uygulanması:
   • PoS algoritmasını uygulamak için, her bir katılımcının sahip olduğu jeton sayısına dayalı olarak yeni blokları doğrulama yetkisine sahip olacağı bir sistem oluşturmanız gerekir. Bu, kullanıcıların jetonlarını stake etmeleri ve buna göre blokları doğrulamaları gerektiği anlamına gelir.
   • Blok oluşturma işlemlerini, PoS algoritmasına göre gerçekleştiren bir mekanizma ekleyin. Bu, mevcut jeton sahiplerinden rastgele birini blok oluşturucu olarak seçmek ve bloğun onayını almak için belirli bir hesaplama süreci gerçekleştirmek olabilir.
5. Konsensüs Mekanizmasının Uygulanması:
   • Bloklar arasındaki konsensüsü sağlamak için gerekli mekanizmaları uygulayın. PoS’de genellikle oybirliği veya en uzun zincir kuralı gibi mekanizmalar kullanılır.
6. Ağ İletişiminin ve Eşler Arası İletişiminin İmplementasyonu:
   • Blokların eşler arasında iletilmesi ve yeni blokların ağa yayılması için iletişim protokollerini ve ağ katmanını uygulayın. Bu, blok senkronizasyonu, yeni blok ekleme ve işlem iletişimi gibi işlevleri içerir.
7. Güvenlik ve Performans İyileştirmeleri:
   • Güvenlik açıklarını önlemek için gerekli kontrolleri ekleyin. Ayrıca, performansı artırmak için çeşitli optimizasyonları düşünebilirsiniz.
8. Testlerin Eklenmesi ve Kodun Denenmesi:
   • Kodunuzu test etmek ve doğrulamak için kapsamlı bir test süiti oluşturun. Bu, yazılımınızın doğru çalıştığını ve beklenen sonuçları ürettiğini doğrulamanıza yardımcı olacaktır.
9. Belgelendirme ve Topluluk İletişimi:
   • Projenizi belgeleyin ve açıklayıcı dökümantasyonlar ekleyin. Ayrıca, topluluğunuzu bilgilendirmek ve geri bildirim almak için forumlar, tartışma grupları veya diğer iletişim kanallarını kullanın.

Bu adımları takip ederek, Rust ile PoS algoritmasını kullanan bir blockchain ağı oluşturabilirsiniz. Ancak unutmayın ki gerçek bir blockchain ağı geliştirmek ciddi bir zorluk ve zaman gerektirir. Bu nedenle sabırlı olun ve projenizi adım adım ilerletin.

PoS Algoritmalı BlockChain Kodu

use std::time::{Instant, Duration};
use ring::digest;

// Blok yapısı
#[derive(Debug, Clone)]
struct Block {
    index: usize,
    timestamp: u64,
    data: String,
    previous_hash: Vec<u8>,
    hash: Vec<u8>,
    validator: String,
}

impl Block {
    fn new(index: usize, timestamp: u64, data: String, previous_hash: Vec<u8>, validator: String) -> Self {
        let hash = Block::calculate_hash(index, timestamp, data.as_str(), &previous_hash);
        Block { index, timestamp, data, previous_hash, hash, validator }
    }

    fn calculate_hash(index: usize, timestamp: u64, data: &str, previous_hash: &[u8]) -> Vec<u8> {
        let input = format!("{}{}{}{}", index, timestamp, data, previous_hash);
        digest::digest(&digest::SHA256, input.as_bytes()).as_ref().to_vec()
    }
}

// Blockchain yapısı
struct Blockchain {
    blocks: Vec<Block>,
}

impl Blockchain {
    fn new() -> Self {
        let genesis_block = Block::new(0, Instant::now().elapsed().as_secs(), String::from("Genesis Block"), vec![], String::from("Genesis Validator"));
        Blockchain { blocks: vec![genesis_block] }
    }

    fn add_block(&mut self, data: String, validator: String) {
        let previous_block = self.blocks.last().unwrap();
        let new_index = previous_block.index + 1;
        let new_timestamp = Instant::now().elapsed().as_secs();
        let new_hash = Block::calculate_hash(new_index, new_timestamp, data.as_str(), &previous_block.hash);
        let new_block = Block { index: new_index, timestamp: new_timestamp, data, previous_hash: previous_block.hash.clone(), hash: new_hash, validator };
        self.blocks.push(new_block);
    }

    fn is_valid(&self) -> bool {
        for (i, block) in self.blocks.iter().enumerate() {
            if i == 0 {
                continue; // Genesis block always valid
            }
            let previous_block = &self.blocks[i - 1];
            if block.index != previous_block.index + 1 {
                return false;
            }
            if block.previous_hash != previous_block.hash {
                return false;
            }
            if block.hash != Block::calculate_hash(block.index, block.timestamp, block.data.as_str(), &block.previous_hash) {
                return false;
            }
        }
        true
    }

    fn get_validator(&self, index: usize) -> Option<&str> {
        if index < self.blocks.len() {
            Some(&self.blocks[index].validator)
        } else {
            None
        }
    }
}

// PoS Algoritması
struct ProofOfStake {
    validators: Vec<String>,
}

impl ProofOfStake {
    fn new(validators: Vec<String>) -> Self {
        ProofOfStake { validators }
    }

    fn select_validator(&self, block_index: usize) -> String {
        let validator_index = block_index % self.validators.len();
        self.validators[validator_index].clone()
    }
}

// Konsensüs Mekanizması
struct Consensus {
    blockchain: Blockchain,
    pos: ProofOfStake,
}

impl Consensus {
    fn new(validators: Vec<String>) -> Self {
        let pos = ProofOfStake::new(validators);
        let blockchain = Blockchain::new();
        Consensus { blockchain, pos }
    }

    fn add_block(&mut self, data: String) {
        let last_block_index = self.blockchain.blocks.len() - 1;
        let validator = self.pos.select_validator(last_block_index);
        self.blockchain.add_block(data, validator);
    }

    fn is_valid(&self) -> bool {
        self.blockchain.is_valid()
    }

    fn get_validator(&self, block_index: usize) -> Option<&str> {
        self.blockchain.get_validator(block_index)
    }
}

fn main() {
    let validators = vec![
        String::from("Validator 1"),
        String::from("Validator 2"),
        String::from("Validator 3"),
    ];
    let mut consensus = Consensus::new(validators.clone());

    consensus.add_block(String::from("Block 1 Data"));
    consensus.add_block(String::from("Block 2 Data"));

    println!("Blockchain is valid: {}", consensus.is_valid());

    for (i, validator) in validators.iter().enumerate() {
        if let Some(block_validator) = consensus.get_validator(i) {
            println!("Block {} is validated by {}", i+1, block_validator);
            assert_eq!(validator, block_validator);
        }
    }
}

Ağ İletişimi

use std::net::{TcpListener, TcpStream};
use std::io::{Read, Write};
use std::thread;

// Basit bir mesaj tipi
#[derive(Debug)]
enum Message {
    NewBlock(String),
}

// Blok zinciri eşler arası iletişim işlevleri
struct PeerToPeer {
    peers: Vec<String>,
}

impl PeerToPeer {
    fn new(peers: Vec<String>) -> Self {
        PeerToPeer { peers }
    }

    // Bir bloğu ağdaki diğer eşlere yayma
    fn broadcast(&self, block_data: String) {
        for peer in &self.peers {
            if let Ok(mut stream) = TcpStream::connect(peer) {
                let message = Message::NewBlock(block_data.clone());
                let serialized_message = serde_json::to_string(&message).unwrap();
                stream.write_all(serialized_message.as_bytes()).unwrap();
            }
        }
    }

    // Diğer eşlerden gelen mesajları dinleme
    fn listen(&self, listener: TcpListener) {
        for stream in listener.incoming() {
            match stream {
                Ok(mut stream) => {
                    let mut buffer = [0; 1024];
                    match stream.read(&mut buffer) {
                        Ok(_) => {
                            let message: Message = serde_json::from_slice(&buffer).unwrap();
                            println!("Received message: {:?}", message);
                        }
                        Err(e) => {
                            println!("Error reading from stream: {:?}", e);
                        }
                    }
                }
                Err(e) => {
                    println!("Error accepting connection: {:?}", e);
                }
            }
        }
    }
}

fn main() {
    let peers = vec![
        String::from("127.0.0.1:8081"),
        String::from("127.0.0.1:8082"),
        String::from("127.0.0.1:8083"),
    ];

    // Eşler arası iletişim yöneticisi oluşturma
    let p2p = PeerToPeer::new(peers.clone());

    // Diğer eşlerle iletişim için dinleyici başlatma
    for peer in &peers {
        let listener = TcpListener::bind(peer).unwrap();
        let p2p_clone = p2p.clone();
        thread::spawn(move || {
            p2p_clone.listen(listener);
        });
    }

    // Örnek bir blok oluşturma ve ağdaki diğer eşlere yayma
    let block_data = String::from("Sample Block Data");
    p2p.broadcast(block_data);
}

Rust dilini öğrenmek isteyenler aşağıdaki Medium makalesini okuyabilirler:

Rust’ı Öğrenmek – 2024

Mutlu kodlamalar