İşlevsel Programlama savunucuları bu ifadeye Kod Tamamlama'da nasıl cevap verebilir?

İkinci baskının 839. sayfasında, Steve McConnell, programcıların büyük programlarda "karmaşıklığı ele geçirme" yollarını tartışıyor. Tüyoları bu ifadeyle sonuçlandı:

"Nesneye yönelik programlama , aynı zamanda algoritmalar ve veriler için geçerli olan bir soyutlama düzeyi sağlar , yalnızca işlevsel ayrışmanın tek başına sağlamadığı bir tür soyutlama sağlar."

"Karmaşıklığın azaltılması tartışmalı olarak etkili bir programcı olmanın en önemli anahtarıdır" (aynı sayfa) olduğu sonucuyla birleştiğinde, bu durum işlevsel programlama için oldukça zorlu görünüyor.

FP ve OO arasındaki tartışma genellikle, özellikle eşzamanlılık veya paralelleştirme zorluklarından türetilen karmaşıklık meseleleri etrafındaki FP savunucuları tarafından çerçevelenir. Ancak eşzamanlılık kesinlikle programcıların fethetmesi gereken tek karmaşıklık yazılımı değildir. Belki bir çeşit karmaşıklığı azaltmaya odaklanmak, diğer boyutlarda onu büyük ölçüde arttırır, öyle ki çoğu durumda kazancınız maliyete değmez.

FP ve OO arasındaki karşılaştırma şartlarını eşzamanlılık veya yeniden kullanılabilirlik gibi belirli konulardan küresel karmaşıklığın yönetimine kaydırırsak, bu tartışma nasıl görünür?

DÜZENLE

Vurgulamak istediğim karşıtlık, OO'nun hem veri hem de algoritmaların karmaşıklığını kapsamaya ve soyutlamaya başlamış gibi görünmesine karşın, işlevsel programlama, program boyunca veri yapılarının uygulama ayrıntılarını daha "ortaya çıkaran" bırakmaya teşvik ediyor gibi görünüyor.

Bakınız, mesela, Stuart Halloway (a Clojure FP savunucusu) burada "veri türleri aşırı şartname" "deyimsel OO tarzı negatif sonucu" olduğunu söyleyerek ve basit bir vektörü olarak bir AddressBook kavramsallaştırma ya da bunun yerine daha zengin OO nesnesinin haritasına lehine ek (vectorish olmayan ve maplike olmayan) özellikler ve yöntemler ile. (Ayrıca, OO ve Etki Alanına Dayalı Tasarım taraftarları, bir Adres Defterini bir vektör veya harita olarak göstermenin, kapsüllenmiş verileri, etki alanı açısından alakasız veya hatta tehlikeli olan yöntemlere maruz bıraktığını söyleyebilirler).

Kitabın 20 yıldan uzun bir süredir yazıldığını unutmayın. Günün profesyonel programcıları için FP yoktu - tamamen akademisyenler ve araştırmacılar dünyasındaydı.

İşin uygun bağlamında "işlevsel ayrışmayı" çerçevelemeliyiz. Yazar işlevsel programlamadan bahsetmiyor. Bunu “yapılandırılmış programlama” ya da GOTOondan önce gelen doldurulmuş karışıklığa bağlamamız gerekiyor. Referans noktanız eski bir FORTRAN / COBOL / BASIC ise, işlevleri olmayan (belki de şanslıysanız GOSUB seviyesini alırsınız) ve tüm değişkenleriniz globaldir, programınızı bozabilir fonksiyonların katmanları içine büyük bir nimet olduğunu.

OOP, bu tür 'işlevsel ayrışma' üzerine bir başka ayrıntılandırmadır. Komutları sadece fonksiyonlarda bir araya getirmekle kalmaz, aynı zamanda ilgili fonksiyonları üzerinde çalıştıkları verilerle gruplayabilirsiniz . Sonuç, verilerinizde başka neler çalışabileceğini bulmak için kod tabanınızın her yerinde kovalamak zorunda kalmadan bakabileceğiniz ve anlayabileceğiniz (ideal olarak) açıkça tanımlanmış bir kod parçasıdır.

İşlevsel programlama destekçilerinin çoğu FP dilinin "yalnızca işlevsel ayrıştırma" dan daha fazla soyutlama aracı sağladığını ve aslında Nesne Yönelimli Dillerinkilerle karşılaştırılabilir soyutlama araçlarına izin verdiğini iddia edeceğini düşünüyorum. Örneğin, Haskell'in tip sınıflarını veya ML'nin yüksek dereceli modülleri bu tür soyutlamalar olarak gösterebilir. Bu nedenle (eminim nesne yönelimi ile işlemsel programlama değil işlevsel programlama hakkındaydı) ifadesi onlar için geçerli değildir.

Ayrıca, FP ve OOP'nin dikgen kavramlar olduğu ve karşılıklı olarak dışlanmadıkları belirtilmelidir. Bu yüzden onları birbirleriyle karşılaştırmanın anlamı yoktur. "İşlemsel OOP" (örneğin Java) ve "işlevsel OOP" (örneğin Scala) ile çok iyi bir şekilde karşılaştırabilirsiniz, ancak alıntı yaptığınız ifade bu karşılaştırma için geçerli olmaz.

İşlevsel programlamayı karmaşıklığı yönetmede son derece yararlı buluyorum. Karmaşıklık hakkında farklı düşünmeyi düşünüyorsunuz, bunu bir OOP anlamında kapsülleme yerine farklı seviyelerde değişmez veriler üzerinde etki eden fonksiyonlar olarak tanımlayabilirsiniz.

Örneğin yakın zamanda Clojure'da bir oyun yazdım ve oyunun tamamı tek bir değişmez veri yapısında tanımlandı:

(def starting-game-state {:map ....
                          :player ....
                          :weather ....
                          :other-stuff ....}

Ve ana oyun döngüsü, bazı saf fonksiyonların bir oyun döngüsünde oyun durumuna uygulanması olarak tanımlanabilir:

 (loop [initial-state starting-game-state]
   (let [user-input (get-user-input)
         game-state (update-game initial-state user-input)]
     (draw-screen game-state)
     (if-not (game-ended? game-state) (recur game-state))))

Çağrılan anahtar işlevi update-game, önceki bir oyun durumu ve bazı kullanıcı girişi verilen bir simülasyon adımını çalıştıran ve yeni oyun durumunu döndüren işlevdir .

Peki karmaşıklık nerede? Bana göre oldukça iyi yönetildi:

• Kesinlikle güncelleme oyunu işlevi çok fazla iş yapar, ancak diğer işlevleri bir araya getirerek oluşturulmuştur, bu yüzden aslında oldukça basit bir işlemdir. Birkaç seviyeye indiğinizde, fonksiyonlar hala oldukça basittir ve "harita döşemesine nesne ekleme" gibi bir şey yapar.
• Kesinlikle oyun durumu büyük bir veri yapısıdır. Fakat yine de, daha düşük seviyeli veri yapıları oluşturarak oluşturulmuştur. Ayrıca gömülü herhangi bir yöntem veya sınıf tanımına ihtiyaç duymak yerine "saf veri" dir (eğer istersen bunu çok etkili bir JSON nesnesi olarak düşünebilirsin) bu yüzden çok az kazan var.

OOP, karmaşıklığı enkapsülasyon yoluyla da yönetebilir, ancak bunu OOP ile karşılaştırırsanız, işlevselliğin çok büyük avantajları vardır:

• Oyun durumu veri yapısı değişkendir, bu nedenle birçok işlem kolayca paralel olarak yapılabilir. Örneğin, oyun ekranından oyun mantığından farklı bir iş parçacığına ekran oluşturma çağrısı yapmak tamamen güvenlidir - birbirlerini etkileyemezler veya tutarsız bir durum göremezler. Bu, büyük bir değişken nesne grafiği ile şaşırtıcı derecede zordur
• İstediğiniz zaman oyun durumunun anlık görüntüsünü alabilirsiniz. Replay'ler önemsizdir (Clojure'un kalıcı veri yapıları sayesinde, verilerin çoğu paylaşıldığı için kopyalar neredeyse hiç hafıza almaz). Ayrıca AI'nın farklı hareketleri değerlendirmesine yardımcı olmak için "geleceği tahmin etmek" için güncelleme oyununu çalıştırabilirsiniz.
• Hiçbir yerde, katı bir sınıf heirarşi tanımlamak gibi OOP paradigmasına uyması için herhangi bir zorlu takas yapmam gerekmedi. Bu anlamda, işlevsel veri yapısı daha esnek bir prototip tabanlı sistem gibi davranır.

Son olarak, işlevselliğe ve OOP dillerinde karmaşıklığın nasıl yönetileceği hakkında daha fazla bilgi edinmek isteyen insanlar için, Rich Hickey'in ana konuşması Simple Made Easy ( Strange Loop teknolojisi konferansında çekildi) ana konuşması videosunu şiddetle tavsiye ediyorum.

"Nesneye yönelik programlama, aynı zamanda algoritmalar ve veriler için geçerli olan bir soyutlama düzeyi sağlar, yalnızca işlevsel ayrışmanın tek başına sağlamadığı bir tür soyutlama sağlar."

İşlevsel ayrıştırma tek başına herhangi bir algoritma veya program yapmak için yeterli değildir: verileri de temsil etmeniz gerekir. Yukarıdaki ifadenin, işlevsel durumdaki "verinin" ilkel türden olduğunu (yani en basit şekilde) olduğunu ima ettiği (en azından anlaşılabileceği gibi) olduğunu düşünüyorum: sadece sembollerin listesi ve başka hiçbir şey yok. Böyle bir dilde programlama açıkça pek uygun değildir. Bununla birlikte, birçok, özellikle Clojure gibi yeni ve modern, işlevsel (veya çok paradigma) diller zengin veri yapıları sunar: yalnızca listeler değil, aynı zamanda dizeler, vektörler, haritalar ve kümeler, kayıtlar, yapılar - ve nesneler! - meta veri ve polimorfizm ile.

OO soyutlamalarının devasa pratik başarısı pek tartışılmaz. Ama bu son söz mü? Yazdığınız gibi, eşzamanlılık sorunları zaten en büyük acı ve klasik OO hiç bir eşzamanlılık fikri içermiyor. Sonuç olarak, eşzamanlılıkla uğraşmak için fiili OO çözümleri sadece üst üste bindirilmiş koli bandıdır: çalışır, ancak sökülmesi kolaydır, eldeki asıl görevden önemli miktarda beyin kaynağı alır ve iyi ölçeklenemez. Belki birçok dünyanın en iyisini elde etmek mümkündür. Modern çoklu paradigma dillerinin peşinde olduğu şey bu.

Değişken durum, programlama ve yazılım / sistem tasarımı ile ilgili çoğu karmaşıklığın ve problemin köküdür.

OO değişken durumu kucaklar. FP değişken durumdan nefret eder.

Hem OO hem de FP kendi kullanımlarına ve tatlı noktalarına sahiptir. Akıllıca seçim. Ve atasözünü hatırlayın: "Kapaklar zavallı adamın nesneleridir. Nesneler fakir adamın kapanışıdır."

İşlevsel Programlamanın nesneleri olabilir, ancak bu nesneler değişmez olma eğilimindedir. Saf fonksiyonlar (yan etkisi olmayan fonksiyonlar) daha sonra bu veri yapılarında çalışır. Nesne yönelimli programlama dillerinde değişmez nesneler yapmak mümkündür, ancak bunu yapmak için tasarlanmamışlardır ve kullanma eğilimi bu değildir. Bu, nesneye yönelik programlar hakkında akıl yürütmeyi zorlaştırır.

Çok basit bir örnek alalım. Diyelim ki Oracle, Java Dizelerinin ters yöntem kullanması gerektiğine karar verdi ve siz de aşağıdaki kodu yazdınız.

String x = "abc";
StringBuffer y = new StringBuffer(x);
y.reverse();
x.reverse();
x.toString().equals(y.toString());

Son satır neye değer veriyor? Bunun yanlış olarak değerlendirileceğini bilmek için String sınıfının özel bilgisine ihtiyacınız var.

Ya kendi sınıfımı WuHoString yaptıysam

String x = "abc";
WuHoString y = new WuHoString(x);
y.reverse();
x.reverse();
x.toString().equals(y.toString())

Son çizginin neye benzediğini bilmek imkansız.

İşlevsel Programlama tarzında aşağıdaki gibi daha çok yazılır:

String x;
equals(toString(reverse(x)), toString(reverse(WuHoString(x))))

ve doğru olmalı.

En temel sınıflardan birindeki 1 fonksiyonun akla gelmesi çok zorsa, o zaman bu değişken nesneler fikrini ortaya koyarsanız, karmaşıklığı arttırmış veya azaltmış olursunuz.

Açıkçası, nesne yönelimini neyin oluşturduğunun ve işlevsel olmanın ne anlama geldiğinin ve her ikisinin de ne anlama geldiğinin her türlü tanımı vardır. Bana göre, birinci sınıf işlevler gibi şeyler içermeyen ama başka diller için yapılmış dilbiliminde "işlevsel bir programlama stiline" sahip olabilirsiniz.

Bence çoğu zaman klasik OOP soyutlaması eşzamanlılık karmaşıklığını kapsamıyor. Bu nedenle OOP (orijinal anlamıyla) FP'yi dışlamaz ve bu yüzden scala gibi şeyleri görürüz.

Cevap dile bağlıdır. Lisps, örneğin, kod düzgün gerçekten düzgün olması ise aslında sadece Lisp listeleri yazma algoritmaları - veri! Verileri, programı yazdığınız gibi saklarsınız. Bu soyutlama, eşzamanlı olarak OOP'tan daha basit ve daha ayrıntılıdır ve gerçekten güzel şeyler yapmanıza izin verir (makroları kontrol edin).

Haskell (ve benzer bir dil, sanırım) tamamen farklı bir cevabı var: cebirsel veri türleri. Bir cebirsel veri türü bir Cyapıya benzer, ancak daha fazla seçeneğe sahiptir. Bu veri türleri, verileri modellemek için gereken soyutlamayı sağlar; fonksiyonlar, algoritmaları modellemek için gereken soyutlamayı sağlar. Tip sınıfları ve diğer gelişmiş özellikler, her ikisinde de daha yüksek bir soyutlama düzeyi sağlar.

Örneğin, eğlence için TPL adlı bir programlama dili üzerinde çalışıyorum. Cebirsel veri türleri değerleri göstermeyi gerçekten kolaylaştırır:

data TPLValue = Null
              | Number Integer
              | String String
              | List [TPLValue]
              | Function [TPLValue] TPLValue
              -- There's more in the real code...

Ne bu diyor - Çok görsel bir şekilde - bir TPLValue (dilimde herhangi bir değer) bir olabilmesidir Nullveya Numberbir ile Integerdeğer veya hatta bir Functiondeğerler (parametreler) listesiyle ve nihai değere (vücut ).

Sonra bazı ortak davranışları kodlamak için type sınıflarını kullanabilirim. Örneğin, bir dize dönüştürülebilir anlamına gelir TPLValueve bunun örneği Showyapabilir.

Ek olarak, bazı tiplerin davranışını (kendimi uygulamadığımlar da dahil) belirtmem gerektiğinde kendi tip sınıflarımı kullanabilirim. Örneğin, Extractablea alan TPLValueve uygun normal bir değer döndüren bir işlev yazmama izin veren bir tür sınıfım var . Bu nedenle extract, bir dönüştürme Numberbir etmek Integerya da bir Stringa Stringuzun kadar Integerve Stringörnekleridir Extractable.

Son olarak, benim programın ana mantık gibi çeşitli fonksiyonlarda olduğu evalve apply. Bunlar gerçekte çekirdektir - durumları ve hataları ele almanın yanı sıra, TPLValues'yi alır ve daha fazla TPLValues'a dönüştürürler .

Genel olarak, Haskell kodumda kullandığım soyutlamalar aslında OOP dilinde kullandıklarımdan daha güçlü.

Alıntılanan cümlenin, görebildiğim kadarıyla artık bir geçerliliği yok.

Çağdaş OO dilleri, cinsi * olmayan türler üzerinde soyut olamaz, yani yüksek türler bilinmemektedir. Tip sistemleri, "elemanlar üzerinde bir fonksiyonun haritalanmasına izin veren, Int elemanlı bazı kaplar" fikrinin ifade edilmesine izin vermez.

Dolayısıyla, bu temel fonksiyon Haskells gibi

fmap :: Functor f => (a -> b) -> f a -> f b 

Java ile kolayca yazılamaz *), örneğin, en azından güvenli bir şekilde değil. Bu nedenle, temel işlevsellik elde etmek için çok sayıda kazan plakası yazmanız gerekir, çünkü

1. Bir listenin elemanlarına basit bir fonksiyon uygulamak için bir yöntem
2. Bir dizinin elemanlarına aynı basit işlevi uygulamak için bir yöntem
3. Aynı basit işlevi karma değerlerine uygulamak için bir yöntem,
4. .... ayarla
5. .... ağaç
6. ... 10. aynı ünite testleri

Yine de, bu beş yöntem temelde aynı koddur, verir veya alır. Aksine, Haskell'de ihtiyacım olan şey:

1. Liste, dizi, harita, küme ve ağaç için bir Functor örneği (çoğunlukla önceden tanımlanmış veya derleyici tarafından otomatik olarak türetilebilir)
2. basit işlev

Bunun Java 8 ile değişmeyeceğine dikkat edin (yalnızca biri işlevleri daha kolay uygulayabilir, ancak o zaman tam olarak yukarıdaki sorun ortaya çıkacaktır. Daha üst düzey işlevlere sahip olmadığınız sürece büyük olasılıkla daha yüksek türler için neyin iyi olduğunu anlayabilecektir.)

Ceylon gibi yeni OO dilleri bile daha yüksek türlere sahip değildir. (Son zamanlarda Gavin King'e sordum ve bana şu anda önemli olmadığını söyledi.) Yine de Kotlin'i bilmiyorum.

*) Adil olmak gerekirse, fmap yöntemi olan bir arayüz Functor'a sahip olabilirsiniz. Kötü bir şey, söyleyemezsiniz: Hey, SuperConcurrentBlockedDoublyLinkedDequeHasMap kütüphane sınıfı için fmap'ın nasıl uygulanacağını biliyorum, sevgili derleyici, lütfen bundan sonra tüm SuperConcurrentBlockedDoublyLinkedDequeHasMaps'ın Functors olduğunu kabul edin.

DBase'de programlanmış olan herkes, tek satırlı makroların yeniden kullanılabilir kod yapmak için ne kadar yararlı olduğunu bilirdi. Lisp'te programlanmadıysam da, derleme zamanı makrolarıyla yemin eden birçok insandan okudum. Derleme zamanında kodunuza kod ekleme fikri, "include" yönergesiyle her C programında basit bir biçimde kullanılır. Lisp bunu bir Lisp programıyla yapabilir ve Lisp oldukça yansıtıcı olduğundan, çok daha esnek içerikler elde edersiniz.

Web'den rasgele bir metin dizesi alıp veritabanına ileten herhangi bir programcı bir programcı değildir. Aynı şekilde, "kullanıcı" verilerinin otomatik olarak çalıştırılabilir kod haline gelmesine izin verebilecek olan herkes aptaldır. Bu, programların yürütme sırasında verileri değiştirmesine ve ardından kodu kod olarak çalıştırmasına izin vermenin kötü bir fikir olduğu anlamına gelmez. Gelecekte, çoğu program yazan "akıllı" kodlara sahip olacak olan bu tekniğin vazgeçilmez olacağına inanıyorum. Tüm "veri / kod sorunu" olup olmaması, dilde güvenlik konusudur.

Çoğu dilde yaşanan sorunlardan biri, bir satır öteye gidene, bazı işlevleri kendileri için yürütebilecek şekilde yapılmasıdır. Gerçek dünya programları, birçok kişinin her zaman ve aynı anda birden fazla Çekirdek ve çoklu bilgisayar kümesinden erişebilmesini gerektirir. Güvenlik, işletim sistemi yerine dilin bir parçası olmalı ve çok uzak olmayan bir gelecekte olacaktır.