Programlamanın Yedi Prototip Dili (2022)

 (madhadron.com)
48 puan yazan GN⁺ 10 일 전 | 5 yorum | WhatsApp'ta paylaş
  • Tekil sözdizimlerinden çok temel örüntü kümeleri arasındaki farklar daha önemlidir; programlama dilleri yineleme, özyineleme ve yapılandırma biçimlerine göre yedi prototip dile ayrılır
  • ALGOL, Lisp, ML, Self, Forth, APL, Prolog temel sınıflandırmayı oluşturur; her aile, diğer dillerin soyunu değerlendirmek için temsilî bir dili referans örnek olarak alır
  • Aşina olunan bir prototip dili paylaşan yeni bir dili öğrenmek kolaydır, ancak yabancı bir prototipe geçildiğinde yeni düşünme yolları ve hatırı sayılır öğrenme süresi gerekir
  • ALGOL atama, koşul ve döngü merkezli işlev organizasyonuyla; Lisp makrolar ve liste olarak kod ile; ML birinci sınıf fonksiyonlar ve özyineleme ile; Self mesajlaşan nesneler ile; Forth yığın tabanlı sözdizimi ile; APL n boyutlu diziler ile; Prolog ise olgular ve arama yapısıyla öne çıkar
  • Tüm programcılar için önce ALGOL ailesi dillerde yetkinleşmek önceliklidir; ardından SQL öğrenmek ve sonrasında yabancı prototip dilleri düzenli olarak edinmek uzun vadede daha avantajlıdır

Programlamanın Yedi Prototip Dili

  • Programlama dili seçerken, tekil sözdizimi farklarından çok temel örüntüleri edinmek daha önemlidir; benzer ailelerde dizi dolaşımı ya da kombinasyon dolaşımı gibi temel yapılar neredeyse aynı biçimdedir
  • Farklı dil aileleri yineleme, özyineleme ve programı kurma biçimi açısından büyük ölçüde ayrılır; bu temel örüntü kümeleri de birbirinden farklı prototip dilleri oluşturur
  • Aşina olunan bir prototip dili paylaşan yeni bir dili öğrenmek görece kolay bir geçiştir, ancak yabancı bir prototip dile geçerken ciddi zaman ve yeni düşünme yolları gerekir
  • Yazılım alanında tanınan prototip diller yedi tanedir: ALGOL, Lisp, ML, Self, Forth, APL, Prolog
  • Her prototip dil, belirli bir temsilî dili referans örnek olarak alarak sınıflandırılır; diğer diller de bu örnekle karşılaştırılarak hangi soya ait olduklarına göre değerlendirilir

  • ALGOL

    • Program, atamalar, koşullu ifadeler ve döngülerden oluşan bir dizi halinde kurulur ve işlevler etrafında örgütlenir
    • Birçok dil buna modül sistemleri, yeni veri türü tanımlama yolları, çok biçimlilik, istisnalar veya coroutine gibi alternatif denetim akışı yapıları ekler
    • Günümüzde yaygın kullanılan programlama dillerinin çoğu bu prototip dil soyuna aittir
    • ALGOL’ün kendisinde ALGOL 58, ALGOL 60, ALGOL W, ALGOL 68 bulunur
    • Assembly language, Fortran, C, C++, Python, Java, C#, Ruby, Pascal, JavaScript ve Ada bu soya bağlanır
    • En eski prototip dildir; soy ağacı Ada Lovelace’ın Babbage’ın Analitik Makinesi için programları biçimselleştirmesine kadar uzanır
    • EDVAC ve ilk Univac’a uzanan Eckert-Mauchly mimarili bilgisayarların makine dili ve assembly dilleri ile Grace Hopper’ın A-0’ından Fortran ve COBOL’a giden ilk yüksek seviye dil denemeleri bu biçimdedir
    • 1960’larda akademide yapısal programlama gelişerek bu dilleri daha yönetilebilir hale getirdi; bunun sonucu ALGOL 60 oldu ve daha sonra aile üyelerinin çoğu buradan türedi
    • Zamanla diğer prototip dillerin özelliklerini bünyesine katma eğilimi gösterdi
      • 1980’lerde Self ailesi kavramları sınıf biçiminde eklemlenerek veri türü tanımı ve çok biçimliliği gerçekleştirme aracı olarak kullanıldı
      • 2010 sonrasında ML ailesi kavramları da görünmeye başladı

  • Lisp

    • Parantez içine alınmış önek ifadeler ile liste gösterimini birleştiren bir sözdizimine sahiptir
      • (+ 2 3)
      • (defun square (x) (* x x))
      • (* (square 3) 3)
    • Boşlukla ayrılmış öğeleri parantez içine alan liste gösterimi dile gömülüdür; bu yüzden kodun kendisi de liste biçimindedir
    • Makrolar listeleri alıp değiştirdikten sonra değiştirilmiş kodu derleyiciye verebildiğinden, programcılar dilin anlamını yeniden tanımlayabilir
    • Çoğu kod yazımında diğer prototip diller gibi, genellikle ALGOL ya da ML gibi davranma eğilimindedir; ancak ayırt edici nokta makro sistemidir
    • Common Lisp’teki loop sözdizimi de dilin yerleşik bir özelliği değil, makroyla tanımlanmış bir yapıdır
    • Başlangıçta birçok Lisp türevi vardı, ancak topluluk Common Lisp üzerinde uzlaştı
    • Sussman ve Steele, fonksiyonlarla nelerin yapılabileceğini araştırarak Scheme’i yarattı
    • Sayısal hesaplama için Lush, AutoCAD betik dili AutoLISP, Emacs düzenleme davranışlarını gerçekleştiren Emacs Lisp gibi özel amaçlı Lisp’ler kullanıldı
    • Son dönemde Clojure, Lisp ailesinin üçüncü büyük dalı olarak yükseldi
    • Fortran’dan yaklaşık bir yıl sonra ortaya çıkan ve bugün hâlâ kullanılan en eski ikinci dil ailesidir
    • Çıkış noktası, kendi ifadelerini değerlendirebilen bir matematiksel yapının nasıl gösterileceğine dair matematiksel bir soruydu
    • John McCarthy 1958’de buna bir yanıt verdi ve ardından bilgisayarda uygulandı
    • İlk Lisp’ler, matematiksel kökenleri nedeniyle dönemin makineleriyle iyi uyuşmuyordu; bellek ve CPU çevrimi sorunları matematikte olmayan konulardı ve garbage collection gibi teknikler gerekli hale geldi
    • 1970’lerin sonu ile 1980’lerin başında, yalnızca Lisp çalıştırmak için sıfırdan tasarlanmış makineler vardı
    • Bugünkü tümleşik geliştirme ortamlarının birçok ögesi o makinelerde icat edildi
    • Aynı dönemde yapay zeka araştırmalarının ana aracı Lisp’ti; 1980’lerde yapay zeka heyecanı sonuç vermeyince alanla birlikte Lisp de AI Winter içine düştü
    • Buna rağmen hayatta kaldı; bilgisayarların güçlenmesi ve diğer dillerin özelliklerini benimsemesiyle uygulama zorlukları azalmış durumda

  • ML

    • Fonksiyonlar birinci sınıf değerlerdir ve çeşitli fonksiyonları ve etiketli birleşimleri ifade edebilen Hindley-Milner ailesi tür sistemine sahiptir
    • Tüm yineleme özyineleme ile yapılır
      • sum [] = 0
      • sum (x:xs) = x + sum xs
    • Yineleme örüntülerini kapsülleyen fonksiyonlar tanımlanır ve başka fonksiyonlar alarak davranışı uygulayan yapılar da kullanılır
      • map _ [] = []
      • map f (x:xs) = (f x) : (map f xs)
    • Miranda ve Haskell gibi bazı diller varsayılan olarak tembel değerlendirme kullanır
    • Başka diller tür sistemini farklı yönlere genişletmiştir
      • OCaml, Self prototip dili kavramlarıyla birleşmeyi denedi
      • Agda ve Idris, değerlerle türleri karıştıran bağımlı tür sistemlerini benimsedi
      • 1ML, modüllerle türleri birleştirir
    • ML’den CaML, Standard ML, OCaml türedi
    • Miranda, Haskell, Agda, Idris gibi ilişkili soylar da devam etti
    • ML, İngiltere Cambridge’de geliştirilen bir ispat denetleyici programının metalanguage’i idi; adı da buradan gelir
    • Daha sonra bu bağlamın dışına çıkarak bağımsız bir dil olarak yayıldı ve özellikle İngiltere ile Fransa merkezli olarak Avrupa’da popülerlik kazandı

  • Self

    • Program, birbirine mesaj gönderen nesneler kümesi olarak kurulur ve tüm davranışlar bu yolla gerçekleştirilir
    • Yeni nesneler, mevcut nesnelere mesaj gönderilerek oluşturulur
    • Koşullu ifadeler bile true nesnesi ile false nesnesinden birine başvuran bir değişken aracılığıyla gerçekleştirilir
      • Bu iki nesne, doğru olduğunda çalıştırılacak bir fonksiyonla yanlış olduğunda çalıştırılacak başka bir fonksiyonu parametre olarak alan bir mesaj alır
      • true nesnesi ilk fonksiyonu, false nesnesi ise ikinci fonksiyonu çalıştırır
      • Çağıran kod hangi nesne olduğunu bilmez; yalnızca mesaj gönderir
    • Döngüler de aynı şekildedir; uygun nesneler oluşturulup uygun yerlere konursa dilin tüm anlamı yeniden tanımlanabilir
    • Bu tür dillerde kaynak kod genellikle metin dosyalarında değil, canlı bir ortamda saklanır
    • Programcı canlı sistemi değiştirir ve dosyaları derleyip sistemi kurmak yerine o durumun kendisini kaydeder
    • Önemli örnekler Smalltalk ve Self’tir
    • Birçok dil bu ailenin mesaj geçirme tarzını kısmen benimser; buna genellikle nesne yönelimli programlama denir
    • Bunların çoğu Smalltalk temellidir; yalnızca JavaScript, Self’in sınıfsız nesne sisteminden türemesiyle istisna oluşturur
    • Common Lisp’in nesne sistemi, çalışma zamanının çalıştırılacak kodu yalnızca mesaj alan tek nesneye göre değil tüm parametrelere göre seçmesine izin verecek şekilde genellenmiştir
    • Erlang, yürütme akışının nesneler arasında dolaşması yerine, paralel yürütme iş parçacıklarının açıkça mesaj dinleyip gönderdiği bir yöne döner
    • Özgün dil Smalltalk’tır ve 1970’lerin sonu ile 1980’lerde Xerox Parc’ta geliştirildi
    • 1980’lerde çeşitli ticari Smalltalk sistemleri vardı; IBM, başka diller için programlama araçları olan VisualAge koleksiyonunu geliştirmede Smalltalk kullandı
    • Günümüzde Smalltalk başlıca açık kaynak Pharo Smalltalk biçiminde yaşamını sürdürür
    • Smalltalk’ı hızlı ve verimli çalıştırma üzerine çok araştırma yapıldı; bunun zirvesi Strongtalk projesiydi
    • Strongtalk’ın bulgularının Java’nın HotSpot JIT compiler temelini oluşturması tarihsel açıdan önemlidir
    • Smalltalk, önceki dillerin değer ve tür kavramlarını devralarak sınıfları gerçekleştirdi; her nesnenin onu türlendiren bir sınıfı vardı ve sınıf da o türden nesneleri üretiyordu
    • Self, sınıf kavramını çıkarıp yalnızca nesnelerden oluşur
    • Daha saf bir biçim sunduğu için bu prototip dilin referans örneği olarak Self seçilir

  • Forth

    • Yığın dilleri, Lisp’in ters görüntüsü gibidir ve Hewlett Packard’ın ters Polonya gösterimli hesap makineleriyle sözdizimini paylaşır
    • Bir veri yığınına sahiptir; 42 gibi bir sabit yazıldığında bu değer yığına itilir ve fonksiyon adları açık parametreler olmadan yığın üzerinde çalışır
    • Basit aritmetik bile 2 3 + 5 * gibi ters çevrilmiş görünür
    • Fonksiyon tanımı da son derece özlüdür
      • Forth türevlerinin çoğunda : yeni bir sözcük tanımlar
      • square, dup ve * çağrılarıyla aynı anlama gelir
      • dup yığının tepesini çoğaltır, * ise en üstteki iki öğeyi çarpar
    • Ayrıştırıcı ele geçirilebilir ve kendi kodunuzla değiştirilebilir; böylece tüm sözdizimi değiştirilebilir
    • Forth programlarında, Fortran alt kümeleri, paket yerleşimleri ya da durum makinesi geçişlerini gösteren ASCII diyagramlarını doğrudan ayrıştıran küçük diller tanımlamak yaygındır
    • Forth’ün çeşitli türevleri, PostScript, Factor ve Joy buna dahildir
    • Joy, yığın yerine bileşimin matematiksel biçimselliğini kullanan saf işlevsel bir dildir
    • Forth ilk kez 1970’te radyo teleskop kontrolü için yazıldı
    • Sonrasında gömülü sistemlerin geneline geniş ölçüde yayıldı
    • Forth sistemlerini bootstrap etmek yeterince kolay olduğundan, farklı programcıların kendi amaçlarına göre yaptığı onlarca türev ortaya çıktı
    • PostScript, 1980’lerde yazıcılarda belgeleri tanımlamanın esnek bir yolu olarak ortaya çıktı
    • PostScript birçok bakımdan Forth’tan daha kısıtlıdır, ancak grafik yerleşime ilişkin temel işlemleri dilin içine tanımlar

  • APL

    • Dildeki her şey n boyutlu dizilerdir
    • İşleçler bir ya da iki simgeden oluşur ve tüm dizi üzerinde yüksek seviyeli işlemler uygular
    • İfade son derece sıkıştırılmıştır; simge dizisinin kendisi, başka adlar verilmeden de işlemin göstergesi olur
    • Örneğin x değişkeninin ortalaması (+⌿÷≢) x biçiminde hesaplanır
    • APL, J, K başlıca örneklerdir
    • Diziler üzerindeki yüksek mertebeli işlemler MATLAB, NumPy ve R gibi birçok ortama kısmen aktarılmıştır
    • APL, 1960’larda Kenneth Iverson’ın geliştirdiği matematiksel bir gösterimden doğdu ve sonra bilgisayarda uygulandı
    • Yoğun hesaplama yapan insanlar arasında o zamandan beri niş bir destekçi kitlesini korudu
    • Soyundan gelen K dili özellikle finans ortamlarında çok popülerdi

  • Prolog

    • Program, olgular kümesinden oluşur
      • father(bob, ed).
      • father(bob, jane).
    • Değişkenler kullanılarak başka olgulardan olgu türeten topraklanmamış olgular da kullanılır
      • grandfather(X, Y) :- father(X, Z), father(Z, Y).
    • Prolog çalışma zamanı bu olguları ve sorguyu alır, sonucu bulmak için arama yapar
    • Olgu tanımlama yapısı uygun seçilirse Turing tamlığı elde edilir
    • Prolog’daki olguları oluşturan terimler başlı başına özgün veri türleridir ve oluşturulup çalışma zamanına geçirilebilir
    • Bu yönüyle Lisp’teki makrolara ya da Forth’taki ayrıştırıcı değiştirmeye benzer bir konumdadır
    • Prolog programı özünde bir arama olduğundan, veritabanı sorgularında olduğu gibi çoğunlukla arama sırasını ayarlama ve verimsiz yolları erken kesme etrafında ayarlanır
    • Prolog, Mercury, Kanren buna dahildir
    • Bu prototip dil ailesindeki gerçek programlamanın büyük kısmı Prolog’un kendisinde yapılır; topluluk da oldukça birleşiktir
    • 1970’lerde Fransa’daki mantıkçılar, programların birinci dereceden mantık ile ifade edilebileceğini fark edip bunu uygulamaya çalıştı
    • 1980’lerde Japonya’nın beşinci nesil bilgisayar projesi Prolog’a büyük yatırım yaptı; ancak projenin başarısızlığıyla birlikte Prolog’un itibarı da geriledi
    • Buna rağmen, onlarca yıl boyunca Prolog çalışma zamanını çoğu durumda verimli hale getirmek ve yeni özellikler eklemek için araştırmalar sürdü
    • Sayısal kısıtlar gibi özelliklerin eklenmesiyle kısıt mantık programlamasına doğru uzandı
    • Prolog niş alanlarda ortaya çıkmayı sürdürür
      • Java’nın tür denetimi uzun yıllar Prolog ile gerçekleştirildi
      • Facebook’un ilk kaynak kod arama aracı da Prolog tabanlıydı

Nasıl yararlanmalı

  • Çoğu programcı için bu dil ailelerinin bir kısmı ya da tamamı oldukça yabancı görünebilir; ancak her birinin açtığı düşünme yolları ve yeni olanaklar için belli bir zaman yatırımı yapmaya değer
  • ALGOL bakış açısından tamamen farklı görünen iki şeyin, başka bir bakış açısından önemsiz bir karşılaştırma haline gelmesi çok sık rastlanan bir durumdur

  • Öncelik

    • Her programcı ALGOL ailesinden bir dili iyi bilmelidir
    • Bundan sonra Prolog ailesinden bir dil olan SQL öğrenilmesi önerilir
      • Kariyerde ALGOL’den sonra en büyük faydayı sağlayan konumdadır

  • Sonraki genişleme

    • Bu iki aile öğrenildikten sonra, her yıl yabancı bir prototip dil ailesinden yeni bir dil öğrenmek uzun vadede kazanç sağlar
    • Her aile için önerilen dil ve sıra şu şekildedir
      • Lisp: PLT Racket
      • ML: Haskell
      • Self: Self
      • Prolog: Prolog
      • Forth: gForth
      • APL: K, ok üzerinden kullanılarak

  • Sırayı ayarlama

    • Çok sayısal hesap yapıyorsanız K’yi daha erken öğrenmek uygundur
    • Çok gömülü programlama yapıyorsanız gForth’u daha erken öğrenmek uygundur
    • Ancak sıranın kendisi ya da tam olarak hangi dili seçtiğiniz o kadar da önemli değildir
    • Haskell yerine Standard ML ya da OCaml, PLT Racket yerine Common Lisp, gForth yerine Factor öğrenmek de uygundur

  • Dipnotlardaki ekler

    • SQL öğrendikten sonra bile Prolog’un kendisini öğrenmek hâlâ gereklidir
      • Çünkü gerçek kullanım biçimi SQL’den oldukça farklıdır
    • Forth’u derinlemesine anlamak için bir Forth uygulamasını doğrudan yazmanın yaygın bir yaklaşım olduğuna dair okur görüşü de yer alır
      • Forth’un, tek bir kişinin görece kısa sürede sıfırdan uygulayabileceği kadar küçük olduğu belirtilir
      • gForth, ANS Forth öğrenmek için iyi bir uygulamadır
      • Öğrenme kaynağı olarak McCabe’in FORTH Fundamentals, Volume 1 kitabı anılır
      • Birlikte bakılabilecek başka Forth’ler olarak PygmyForth, eForth, colorForth anılır

İlgili okumalar

5 yorum

 
zkj9404 9 일 전

Eğlenceliymiş.
 
tazuya 9 일 전

Üniversitedeyken ALGOL ailesi, Lisp ve Prolog ile bölüm dersleri görüp ödevler yapmıştım; anıları tazeledi.
 
mhcoma 9 일 전

Bu diller modern ana akım programlama dillerine çok şey bıraktı,
ama bunların arasında yalnızca Forth'un etkisi daha az gibi görünüyor.
 
click 9 일 전

Ön ek gösterimini bilmeseniz bile, son ek gösterimiyle kod yazmak gerçekten fazla kullanışsız.
 
GN⁺ 10 일 전
Hacker News görüşleri

  • Tufts’taki PL dersinde emirsel, Lisp, ML, Smalltalk öncesindeki 4 dil ailesinin her biri için mini bir sürüm bizzat yapmıştım; o sürecin şimdi ders kitabı olarak da çıkmış olması sevindirici. Eskiden bir Prolog bölümü de vardı, onun çıkarılmış olması üzücü

    • Keşke eksik olan Prolog bölümünü içeren bir sürüm Internet Archive gibi bir yerde olsa

  • Bu yazının sınıflandırmasında tek bir şeyi düzeltecek olsam, Ruby’yi Algol ailesinden ziyade açıkça nesne yönelimli bir dil olarak görürdüm. Smalltalk etkisi büyük ve standart kütüphane adlarında bile map yerine collect gibi izleri kalmış. Ruby’de baştan sona her şey nesnedir ve metot çağrılarını da nesnelere mesaj gönderme kavramıyla anlamak daha doğaldır. Python ile sık sık karşılaştırılsa da evrim yolları epey farklıydı; bugünse benzer bir ekosistem noktasında yakınsamış gibiler. Bana göre Ruby, Python’dan daha sıcakkanlı bir alpaka gibi hissettiriyor

    • Python da new style classes sonrasında fiilen saf bir OOP dili sayılabilir. Hello World seviyesinde çok belli olmasa da, temel tiplerin tamamı da nesne oldu. OOP’yi sevmeyenlere type(42) ve dir(42) göstermek, tamsayıların bile nesne olduğunu vurgulamak için iyi oluyor
    • Belirli bir prototip dili tek başına nesne yönelimli dil diye işaretlemenin insanları daha çok kafa karışıklığına ittiğini düşünüyorum. OO, prosedürel gibi tek bir programlama stiline daha yakın; Python ile C++’ı sırf çoklu kalıtım var diye aynı dil türü altında toplamak zorlama geliyor
    • Deve benzetmesini görünce, camel aslında Perl tarafının simgesi değil miydi diye düşündüm

  • Dil soy ağacına kanıt ifade dilleri diye bir sınıf daha eklemek isterdim. Curry-Howard bağıntısıyla programların aynı zamanda kanıt olduğu aile; Lean bunun tipik örneği. Bunu işlevselin alt sınıfı olarak da görebiliriz ama asıl amacın çalıştırmadan çok doğrulama olması nedeniyle ayrı bir eksen olarak ele alınmayı hak ettiğini düşünüyorum

    • Bana göre teorem ispatı ve karmaşık tipler mevcut dillerin üstüne eklenmiş genişletmeler gibi görünüyor. Agda ve Idris, karmaşık tipler eklenmiş işlevsel diller; Isabelle ve Lean ise buna etkileşimli ispatı da ekliyor. Dafny, emirsel tarafa teorem ve ipuçları ekliyor; ACL2’yi de theorem/hint eklenmiş bir Lisp gibi düşünmek kolay. Ayrıca Rust trait’lerinde görüldüğü gibi typeclasses, işlevsel ve emirsel dillerin üstünde çalışan bir tür mantıksal programlama gibi geliyor
    • Bu ailelerin tanım gereği Turing tamlığı yok, bu yüzden onları gerçek programlama dili olarak görmek zor diye düşünüyorum. Eğer Turing-tam olsalar, sonlanmayan programlarla sahte kanıtlar üretmek mümkün olurdu
    • Bence bu akış sonuçta doğrudan ML’den türemiş bir çizgi
    • Lean açıkça Agda ve Idris’e yakın, dependent typed ML-family bir dil; bu yüzden geniş açıdan ML sınıfına koyulabilir diye düşünüyorum. Ayrıca Lean’in uzun vadeli hedefi çalıştırmanın ikincil olduğu bir şey gibi de görünmüyor. Microsoft, gerçek yazılım yazımıyla ilgileniyor. Tersine, “kanıtları ifade eden dil” yönünü daha çok vurgularsan Prolog’u da dışarıda bırakmak zorlaşır; o zaman Lean’i yarı ML, yarı Prolog gibi de görebilirsin. Bu bakışta Curry-Howard bağıntısı, hesaplama mantığını gerçekleştirmenin yollarından biri gibi duruyor

  • Yakın zamanda dil karşılaştırma projesine tekrar baktım; 10 karakter için 3,715,891,200 signed permutation’ı paralel olarak cycle decomposition yapan bir benchmark’tı. “Prototip diller”den çok, her paradigmanın modern uygulamaları içinde araştırma amaçlı programlama için gerçekten seçilebilir dilleri bulmak istiyordum. Yalnızca performansa değil, yapay zeka yardımıyla çalışmanın ne kadar kolay olduğuna ve kodu okuyup düşünmenin bana ne kadar uygun geldiğine de baktım; yapay zeka sayesinde her dili epey derin optimize ederek bir tür turistik gezi yapmak da mümkün oldu. Sonuçları burada topladım; özellikle F#’ın en üste çıkması oldukça şaşırtıcıydı

    • İlk bakışta şaşırtıcı ama bence detaylar belirleyici. Lean’i çıkarınca genel olarak farklar çok uç değil ve Chez’in C++’tan 2,5 kat yavaş olması da dinamik tipli bir JIT dili için oldukça iyi. F#’ın bu tür işlerde güçlü görünmesinin nedeni muhtemelen .NET Core üzerindeki paralel işleme deneyiminin özellikle olgun ve sorunsuz olması. Eğer bu sayılar elapsed time ise, CPU time kırılımını da görmek daha ilginç olurdu. Ayrıca dillere göre paralelleştirme stratejileri biraz farklı, yani koşullar tamamen aynı değil. Örneğin F#’ın basit thread bölmesiyle Rust’ın Rayon paralel iterator’ü farklı overhead yapıları taşıyabilir. Sonuçta Rust ve C++, düşük seviyeli OS eşzamanlılık primitive’leri dikkatle ele alınırsa daha da hızlanabilir; ama o da başka tür bir karşılaştırma olur. C ya da Haskell’de C FFI kullanımına izin verilip verilmeyeceği de belirsiz; bu yüzden bu tür karşılaştırmalara doğası gereği bol miktarda nitel değerlendirme karışıyor. Bu arada Chez kodu, permutation’ları fxvector içinde tutup fixnum’a özel işlemler kullanırsa boxing/unboxing ve allocation’ı azaltıp daha da hızlanabilir gibi görünüyor. İlgili belge Chez Scheme nesne dokümanında yer alıyor

  • Ben de benzer bir yazıyı burada yazmıştım. Algol, Lisp, Forth, APL, Prolog’a katılıyorum; ama yenilikçi işlevsel dil olarak ML’den biraz daha eski olan SASL’ı ekledim, nesne yönelimli temsilci olarak da Self’ten önce gelen Smalltalk’ı seçtim. Buna ek olarak Fortran, COBOL, SNOBOL ve Prograph’ı da kendi yöntemleriyle oyunu değiştiren diller olarak dahil ettim

    • Bu liste bana daha çok hitap ediyor. Özellikle SNOBOL’un yer almasına sevindim. Hiç kullanmadım ama çocukken halk kütüphanesindeki kitap satışında adını komik bulup kitaplarından birini elime almıştım; dili ilk öyle öğrenmiştim. Ondan önce yalnızca BASIC, Logo ve Atari BASIC kılavuzundaki örnekleri izleyerek BASIC’ten çağırdığım kadar biraz 6502 assembly biliyordum. Ayrıca yenilikçi dil listesinde Fortran ve COBOL’un ya da onların kökü olan FLOW-MATIC’in eksik olmasını hayal etmek zor. Baktığım kitap Atari BASIC manual tarafındaydı
    • Self yerine neden Smalltalk listeye alınmamış, pek anlayamadım. Smalltalk daha eskiydi ve Alan Kay de “OOP” adını bizzat ortaya atan kişiydi. ML’yi de soy açısından Lisp’in çocuğu olarak görme eğilimindeyim

  • Bu tartışmaya anlamsal aileler de eklemek isterim. Verilog, Petri nets, Kahn process networks, dataflow machines, process calculi, reactive, term rewriting, constraint solver/theorem prover ailesi, probabilistic programming gibi şeyler. Ayrıca mevcut 7 sınıfa tam oturmayan ama fiilen üretim aşamasına yaklaşmış Unison, Darklang, temporal dataflow, DBSP gibi diller de akla geliyor. Biraz hile gibi görülebilir ama bunların çoğu von Neumann tarzı makine modeline paralel hesaplama modelleri. Uzun süredir “Bildiğimiz tüm hesaplama biçimleri, von Neumann’ın ötesinde” gibi bir yazı yazmak istiyorum

    • Böyle bir yazı çıkarsa gerçekten keyifle okurum. Bu arada Steve Yegge’nin bazı yazılarını yeniden hatırlattı. Ana fikir, modern bilgisayar bilimi eğitiminin büyük bölümünün aslında von Neumann’ın kurduğu çerçeve üstünde durduğu ve sıralı aygıt tercihini de dönemin üretim maliyeti ve hız gerçeklerinin şekillendirdiği. Ayrıca öğrendiğimiz makine mimarisi, branch, loop, subroutine, debugging, sayı sistemleri dönüşümü, problem modelleme gibi birçok unsurun zaten onun çalışmalarında bulunduğu vurgulanıyordu. İlgili alıntı archive içinde var
    • term rewriting sözünü görünce, üniversitede spreadsheet yazılımı yaparken formül parser’ını üstlendiğim zamanı hatırladım. İlk başta bir hafta boyunca tıkanmıştım ama sonunda 1+1 ifadesini ADD(1,1) benzeri bir biçime yeniden yazarak bildiğim şekilde parse edebileceğimi fark ettim. Üstelik regex öğrenmeye inatla direndiğim için kod oldukça tuhaflaşmıştı ve bir takım arkadaşımın “Andy çalıştırabiliyorsa dokunmayalım” dediği laf hâlâ aklımda. Başka ekipten biri regex ile benim kodun yaklaşık 20’de 1’i uzunluğunda bir çözüm yazmıştı
    • “Pratiğe hazır yükselen diller” ifadesine bir ek de şu: Bana göre henüz tam anlamıyla production-ready olmasalar bile, gerçek iş ortamında kullanılan ChatGPT benzeri sistemler de benzer bir kategoriye giriyor. Bunları programlama dili sayıp saymamak tartışmalı olabilir ama insanların bilgisayara ne yapmasını istediğini ileten bir aracı olmaları açısından gayet öyle görülebilirler. Belirsiz olmaları da bana göre programlama dillerinin zorunlu özelliği değil
    • Sussman’ın propagators üzerine yazısı da ilginç olabilir
    • S9 Scheme’de logic programming örneği olarak şu kaynak iyiydi. Kitabı almak zorunda olmadan kodu hemen indirebiliyorsun; Simply Scheme gibi giriş seviyesinde bir kaynakla temeli öğrendikten sonra uygularsan solver yapısı oldukça okunaklı geliyor

  • TU Delft’te aldığım “Concepts of programming languages” dersi bilgisayar mühendisliğinde en sevdiğim dersti. C, işlevsel tarafta Scala ve prototip kavramı için JavaScript öğrendik; bu sayede birkaç yıl sonra Elixir öğrenmek çok daha kolay oldu. Ayrıca Unreal Tournament ajanlarını GOAL adlı Prolog tabanlı bir dille yazdığımız bir ders de vardı. Uzun süre Prolog’u nerede kullanacağımı kestirememiştim ama sonunda, LLM’in ürettiği kötü Papiamentu cümlelerini tekrar tekrar düzeltmeye zorlayan bir spellcheck yapmakta kullandım

    • Ben de benzer bir ders aldım; hocam pek iyi değildi ama dersi almaktan son derece memnunum. Başka prototip dilleri yüzeysel bile olsa tanımak ufku genişletiyor; assembly’yi de eklersen etkisi daha da büyük oluyor. Doğrudan üretken bir işte kullanamasan bile, elinde çekiç varken her şeyi çivi gibi görme tuzağından kaçınmana yardımcı oluyor
    • Ben de o dersteydim. Unreal Tournament kısmı gördüğüm en havalı derslerden biriydi; benden sonraki yıl kaldırıldığını hatırlıyorum. Şimdi herkesin aldığı sıradan bir yapay zeka dersine dönmüş gibi, buna üzülüyorum. Ben hâlâ Prolog için çok fazla iyi kullanım alanı bulmuş değilim ama GOAL bende çok daha büyük bir etki bırakmıştı. Ve ancak yakın zamanda, o yapının daha “normal” dillerde de yeniden kurulabileceğini ve bunun pek çok avantajı olduğunu fark ettim; bu da biraz hayal kırıklığı yarattı
    • Buradaki GOAL, Game Oriented Assembly Lisp mi diye merak ettim

  • “Farklı sınıflardan diller öğrenmek gerekir” görüşüne katılıyorum. OCaml öğrendikten sonra fonksiyonlar bana ilk kez gerçekten matematiksel fonksiyonlar gibi hissettirdi; Mathematica ise ifadelerin kendisini girdi olarak görme alışkanlığı kazandırdı. PostScript’in ters Polonya gösterimi, basit aritmetiğin ötesinde düşünme biçimimi resmen yeniden kabloladı. Ama Java, C#, C++, Python, Ruby arasında hangisini seçersen seç fark etmez iddiasına katılmıyorum. Amaç quicksort uygulamaksa benzer olabilirler ama gerçekten bir şeyler üretmek isteyen biri için dil seçimi geceyle gündüz kadar büyük bir fark yaratıyor. 3D oyun yapmak isteyen birine Ruby’yi, keşif odaklı veri bilimi veya derin öğrenme yapmak isteyen birine de önce Java’yı verirsen hevesini kırabilirsin

    • Muhtemelen Rust’tan para kazanmayacağım ama onu öğrendiğime hiç pişman değilim. Rust, program içindeki veri sahipliği üzerine gerçekten derin düşünmeye zorluyor

  • Bu yazı bana Bruce Tate’in 7 languages in 7 weeks kitabını hatırlattı. Ben de Erlang ile ilk kez o kitap sayesinde tanışmıştım. Ama tarihsel olarak COBOL ve Fortran’ı Algol ailesine koymak bana biraz zorlama geliyor; yine de tarihin doğası gereği belli ölçüde indirgemeci özetler içerdiğini hatırlatıyor

    • Daha da geriye gidip ilkel bir sınıflandırma kurmak da zorlama olur diye düşünüyorum. İlk assembly dilleri de emirseldi ama Algol, Fortran ve Cobol’u ilginç yapan şey; fonksiyonlar ve diğer üst düzey özelliklerle karmaşık programlamayı mümkün kılmalarıydı. En çok soy veren Algol oldu ama ilk emirsel programlama dilinin Fortran olduğunu düşünüyorum
    • Wikipedia’ya bakınca Fortran ile Algol’ün ikisinin de 1957 civarında geliştirildiği görülüyor; gerçekte hangisinin daha erken olduğu ve tasarım süreçlerinde birbirlerini etkileyip etkilemedikleri ya da çakışma olup olmadığı merak uyandırdı
    • Belki de COBOL’a yaşayan fosil demek daha doğru olur. Ve bugünkü Fortran da, FORTRAN ailesi tabanına Algol soyunun özelliklerini yatay aktarım yoluyla almış bir dil gibi duruyor

  • Bununla ilgili daha önce bir HN tartışması da vardı. Önceki tartışma da birlikte okunursa bağlamı anlamaya yardımcı olur

    • Daha doğrusu bu, 4 Mayıs 2023 tarihli tartışmaydı ve 323 yorum vardı. Daha eski olarak 30 Eylül 2021’deki şu başlık da vardı; onda ise 29 yorum bulunuyordu