Statik yazım, takaslara değer mi?

Python’da kodlamaya başladım, öncelikle güvenlik türü olmadığı yerde, sonra C # ve Java’ya olduğu yere taşındım. Python'da biraz daha hızlı ve daha az baş ağrısı ile çalışabileceğimi öğrendim, ancak daha sonra yine C # ve Java uygulamalarım çok daha karmaşık bir seviyededir, bu yüzden Python'a asla gerçek bir stres testi yapmadım.

Java ve C # kampları, tür güvenliği olmadan, kulağa pek çok insanın sağdan sola döküldüğü her türlü korkunç böcekle karşılaşacak ve buna değerinden daha fazla sorun yaratabilecek gibi görünüyor.

Bu bir dil karşılaştırması değildir, bu nedenle lütfen yorumlanmış ve derlenmiş vs gibi konuları ele almayın. Tip güvenliği, geliştirme ve esneklik hızını arttırmaya değer midir? NEDEN?

Dinamik yazmanın daha hızlı olduğu görüşüne bir örnek isteyen insanlara:

"Geliştirme sırasında dinamik olarak yazılmış bir dil kullanın. Size daha hızlı geri bildirim, geri dönüş süresi ve geliştirme hızı sağlar." - http://blog.jayway.com/2010/04/14/static-typing-is-the-root-of-all-evil/

Programcıların dinamik olarak yazılmış dillerdeki türler hakkında endişelenmeleri gerekmediği bir efsanedir.

Dinamik olarak yazılmış dillerde:

• Bir dizi, bir tamsayı, bir dize, bir karma tablo, bir işlev başvurusu, bir sözlük, bir nesne ya da her neyse onunla çalışıp çalışmadığınızı hala bilmeniz gerekir.

• Nesne ise, hangi sınıfa ait olduğunu bilmek zorundasın.

• Bu tiplerden birini başka bir tip olması beklenen bir değişken veya işlev parametresine atamak, neredeyse her zaman bir hatadır.

• Daha düşük bir seviyede, örneğin bir TCP paketi dolduruyorsanız, bit sayısı veya imzasız olarak sık sık imzalanan gibi şeyler hala hesaba katılmalıdır.

• Gerçekten boş bir dize istediğiniz bir sıfıra sahip olduğunuz sorunlarla karşılaşabilirsiniz. Başka bir deyişle, hala tür uyuşmazlığı hataları ayıklanıyor. Tek gerçek fark, derleyicinin hataları yakalamamasıdır.

• Çok fazla yazmadığınızdan bile bahsetmediğinizi iddia ediyorum - çünkü yorumlarda işlev parametrelerinizin kodunuzu belgelemek yerine ne tür olduğunu belgelemek isteyebilirsiniz. Bu nedenle, doxygen stili yorum blokları, dinamik olarak yazılmış kod boyunca pratikte çok daha popülerdir, statik olarak yazılmış dillerde genellikle onları kütüphaneler için görürsünüz.

Yani dinamik yazılan dillerde bu programlama olmadığını söylemek değil hissetmek derleyici sırt üstü hep olmadığı için daha hoş ve tecrübeli programcılar statik yazarak yine izleyebiliriz diye hataların tür bulma ve düzeltme zorluk eğilimi yoktur Ancak bu, statik yazarken bile dinamik yazmanın en iyi olduğu verimlilik veya hata oranındaki düşüş iddiasıyla tamamen ayrı bir konudur.

Tipleri daha güçlü olsun, onlar daha size yardımcı olabilir - eğer bunları savaşmanın doğru yerine bunları kullanın. Türlerinizi sorun alanınızı yansıtacak şekilde tasarlayın ve mantık hatalarının çalışma zamanı çökmeleri veya saçma sonuçlar yerine derleme zamanı türü uyuşmazlıkları olma olasılığı daha yüksektir.

Feragatname: Ben bir tip aşığıyım;)

Sorunuzu cevaplamak zor: Bu takaslar nelerdir?

Aşırı bir örnek alacağım: Haskell , statik olarak yazılmıştır. Belki de var olan en güçlü şekilde yazılmış dillerden biri.

Bununla birlikte, Haskell, Genel Programlamayı , belirli bir konsepte (veya arayüze) uyan herhangi bir tipte çalışan yöntemleri yazmanız anlamında destekler .

Ayrıca, Haskell Type Inference'ı kullanır , böylece değişkenlerinizin türünü asla beyan etmenize gerek kalmaz. Derleme sırasında statik olarak hesaplanırlar, Python Tercümanı programı çalıştıracak şekilde hesaplar.

Statik yazmaya zorlanan çoğu insanın aslında başka bir şeyden şikayet ettiğini (fiiliyet, bir türü diğerinin lehine değiştirmenin acısı) şikayet ettim, ancak Haskell statik olarak yazarken, bu sorunların hiçbirini göstermiyor ...

Kısalık örneği:

-- type
factorial :: Integer -> Integer

-- using recursion
factorial 0 = 1
factorial n = n * factorial (n - 1)

Yerleşik desteğin yanı sıra, daha kısa sürede elde etmek zor.

Genel Programlama Örneği:

> reverse "hell­o" -- Strings are list of Char in Haskell
=> "olleh"
> reverse [1, 2, 3, 4, 5]
=> [5,4,3,2,1]

Tür Çıkarımı Örneği:

> :t rever­se "hell­o"
:: [Char]

basitçe hesaplanabilir:

• "hello"bir listesidir Char(olarak ifade edilir [Char])
• reversebir türe uygulanan bir tür [A]döndürür[A]

Tarayıcınızda deneyin

Hem statik hem de dinamik olarak yazılmış dilleri seviyorum. Tip güvenliğin bana göre en büyük iki avantajı:

1) Bir işlevin ne tür bir imzayla yaptığını genellikle çok fazla anlayabilirsiniz (bu özellikle Haskell gibi işlevsel dillerde geçerlidir).

2) Önemli bir refactor yaptığınızda, derleyici otomatik olarak her şeyin çalışmasını sağlamak için yapmanız gereken her şeyi size söyler. C ++ 'da bir şeyi yeniden değerlendirdiğimde prosedürüm genellikle basitçe a) değiştirmek istediğim bir parçayı değiştirip b) her derleme hatasını düzeltmek.

Şahsen, bu tür güvenliğin mevcut işimde daha hızlı gelişmeme yardımcı olduğunu tespit ediyorum. Derleyici, neredeyse yazarken, beni kontrol eden birçok akıl sağlığını uyguluyor, bu da uyguladığım iş mantığına daha fazla odaklanmamı sağlıyor.

Benim için alt çizgi, biraz esneklik kaybetmeme rağmen, aksi halde tip sorunlarını bulmak için harcanacak zaman kazanmam.

Tartışmayı çevreleyen çok sayıda güçlü görüş var ama açıkçası bu aslında bir fikir meselesi değil, gerçekler meselesi . Bu yüzden ampirik araştırmalara bakmalıyız . Ve bundan elde edilen kanıtlar açık:

Evet , statik yazım değiş tokuşa değer - sadece bir miktar değil, aynı zamanda esasen . Aslında, sağlam kanıtlar statik yazmanın koddaki hata sayısını en az% 15 azaltabileceğini göstermektedir (ve bu düşük bir tahmindir, gerçek yüzde neredeyse kesinlikle daha büyüktür). Bu şaşırtıcı derecede yüksek bir rakam: Sanırım çoğu statik yazım yanlısı bile bu kadar sert bir fark yaratabileceğini düşünmüyordu.

Bunu göz önünde bulundurun: eğer biri size projenizdeki hataları% 15 oranında azaltmanın basit bir yolu olduğunu söyleseydi, bu hiç akıllıca olmaz. ¹ Neredeyse meşhur gümüş mermi.

Kanıt, Yazılacak veya Yazılmayacak makalesinde sunulmuştur : JavaScript'te Algılanabilir Hataların Ölçülmesi , Zheng Gao, Christian Bird ve Earl T. Barr. Herkesi okumaya teşvik ediyorum, bu örnek araştırma sunan iyi yazılmış bir makale.

Yazarların analizlerini ne kadar titizlikle yaptıklarını kısaca özetlemek zordur ancak işte size çok kaba bir taslak:

TypeScript ve Flow , uyumlu olmalarına rağmen yazım ipucu ve statik yazım denetimi ekleyen JavaScript'i temel alan iki programlama dilidir. Bu, mevcut kodun türlere göre artırılmasına ve ardından kontrol etmesine izin verir.

Araştırmacılar GitHub'dan JavaScript'te yazılmış Açık Kaynak projeleri topladılar, çözümlenmiş hata raporlarına baktılar ve bildirilen her bir hatayı TypeScript ya da Flow'ın statik tip denetleyicisi tarafından yakalanacak bir koda indirgeme girişiminde bulundular. Bu, statik yazım kullanarak sabitlenebilecek hata yüzdesinin daha düşük bir sınırını tahmin etmelerini sağladı.

Araştırmacılar, analizlerinin türle ilgili olmayan bir hatayı türlerle ilgili olarak değerlendirmemesi için kesin önlemler aldı. ²

Geçmiş çalışmalarla karşılaştırıldığında, bu yeni çalışmanın belirli güçlü yönleri var:

• JavaScript ile TypeScript / Flow arasındaki tek fark yazım olduğundan, çok az (varsa) karıştırıcı faktörle statik ve dinamik yazmanın doğrudan karşılaştırması vardır .
• Hem TypeScript hem de Flow (yani farklı tip sistemler) kontrol ederek ve farklı kişilerin hataları düzeltmek için (manuel) tip ek açıklamaları çoğaltmasını sağlayarak birden fazla boyutta çoğaltma gerçekleştirirler. Bunu farklı projelerden çok sayıda kod temelinde gerçekleştiriyorlar.
• Kağıt, statik yazmanın düzeltilebilir hatalar üzerindeki doğrudan etkisini ölçer (biraz daha belirsiz bir kalite yerine).
• Yazarlar neyin ölçüleceğine ve nasıl ön plana alındığına dair titiz bir model tanımlamaktadır. Dahası, açıklamaları inanılmaz derecede açıktır ve kusurları analiz etmeyi kolaylaştırır (bir araştırma makalesinin kendisini saldırılara açtığı zaman her zaman iyidir: eğer hiçbir saldırı tartışmalarını engelleyemezse, daha da güçlüdür). ³
• Numune büyüklüklerinin yeterli olması için uygun güç analizleri yaparlar ve sonraki istatistiksel analizleri hava sızdırmazdır.
• Şaşırtıcı açıklamaları dışlamak ve sadece tek bir hareketli parçayı ölçmek için aşırı muhafazakarlar. Ayrıca, analizlerini türler ekleyerek anında düzeltilebilecek hatalarla sınırlandırırlar ve yazmayı sağlamak için daha gelişmiş yeniden düzenlemeyi gerektirebilecek her şeyi hariç tutarlar. Yani gerçekte, etki makul bir şekilde çok daha büyük, ama kesinlikle bildirdiklerinden daha küçük değil.
• Ve son olarak, hafif bir etki bulamazlar, şaşırtıcı bir fark bulurlar . Aşırı muhafazakar prosedürlerine rağmen,% 95 güven aralığının en düşük ucunda bile, böceklerin asgari% 10 kontrolleri ile kolayca kaybolabilecekleri en az% 10 hata olduğunu bulmuşlardır.

Kağıtta henüz kimsenin keşfetmediği temel bir kusur olmadığı sürece, kağıt, neredeyse hiç bir ücret ödemeden, statik tiplemenin büyük bir faydasını kesin olarak göstermektedir. ⁴

Tarihsel bir kayda göre, programlamada disiplinleri yazmaya ilişkin araştırmalar sert bir başlangıç ​​yapmış çünkü uzun süredir kanıtlar açık değildi . Bunun nedeni, statik ve dinamik yazmanın etkisini incelemek için sistematik deneyler yapmak kolay değildir: Sistematik bir deney araştırdığımız etkiyi izole etmelidir. Ve ne yazık ki, programlama dillerine bağlı olduğundan, yazma disiplininin etkisini izole edemeyiz.

Aslında farklı lehçelerde hem statik hem de dinamik yazmaya izin veren programlama dilleri vardı (ör. VB Option Strict Onya Offda ya da statik olarak yazılmış Lisp). Bununla birlikte, bunlar doğrudan bir karşılaştırma için pek uygun değildi, çünkü en önemlisi, doğrudan karşılaştırmaya izin veren yeterince büyük bir kod tabanı mevcut değildi. En iyi ihtimalle onları “laboratuvar ayarları” nda karşılaştırabiliriz; burada test konuları rastgele bir dili statik ya da dinamik olarak yazılmış bir değişkende çözer.

Maalesef, bu yapay programlama ödevleri gerçek dünya kullanımını iyi bir şekilde modellemiyor. Özellikle, çoğu kapsam bakımından küçüktür ve metnin yarım sayfasında özetlenebilen iyi tanımlanmış bir sorunu çözer.

Neyse ki geçmişte kaldı, çünkü TypeScript, Flow ve JavaScript aslında statik yazım dışında aynı diller ve geniş bir gerçek dünya kod ve hata kodları örneklemesi var.

_{^{1 Orijinal} belgeden yapılan alıntıdan ilham alınmıştır.}

_{^{2 Bundan} tamamen memnun değilim: statik olarak yazılan dillerin en güçlü yanlarından biri, görünüşte ilişkisiz sorunların statik olarak kontrol edilebilecek şekillerde ifade edilebiliyor olmasıdır. Bu, birçok mantık hatasını tür hatalarına dönüştürür ve bu da statik yazarak yakalanabilecek hata oranını büyük ölçüde artırır. Aslında, kağıt türü ile ilgili olmayan hataları kabaca sınıflandırır ve bunların büyük bir yüzdesinin aslında statik yazarak yakalanabileceğini iddia ediyorum.}

_{³ Herhangi bir kişiyi, özellikle dinamik yazım savunucularını, analizde eksiz kusurları bulmaya davet ediyorum. Çok fazla (varsa) olduğunu düşünmüyorum ve potansiyel bir kusurun sonucu önemli ölçüde değiştirmeyeceğinden eminim.}

_{⁴ Gerçek, büyük ölçekli projelerdeki statik yazım maliyetinin mevcut olmadığından şüpheleniyorum, çünkü mimarinin doğal bir parçası haline geliyor ve hatta planlamayı basitleştirebilir . Statik tip hataların düzeltilmesi zaman alır ancak daha sonra keşfedilen hatalardan çok daha az zaman alır. Bu kapsamlı bir şekilde deneysel olarak çalışılmıştır ve onlarca yıldır bilinmektedir (bkz. Örneğin Kod Tamamlama ).}

Tip güvenliği, geliştirme ve esneklik hızını arttırmaya değer midir?

Yani bu gerçekten yaptığınız şeye bağlı. Programlama diyorsanız, uçaklar için yedekleme sistemleri, güvenlik türünü muhtemelen kullanmanın yoludur.

Dinamik dil vs Statik dil programlama gerçekten iki farklı hayvandır. Her ikisi de birbirinden temel olarak farklı bir yaklaşım gerektirir. Çoğunlukla statik ve dinamik arasında bir yaklaşım yöntemi gösterebilir, ancak diğerinin avantajlarını kaybedersiniz.

Bu gerçekten bir zihniyet. Biri diğerinden daha iyi mi? Bu gerçekten kim olduğunuza ve nasıl düşündüğünüze bağlıdır. Çalıştığım insanların çoğu, mecbur olmasaydı asla dinamik bir dile dokunmazlardı, çünkü hata için çok fazla yer olduğunu düşünüyorlar. Bunu düşünmek yanlış mı? Hayır, elbette değil, ama kodlama stillerini uygulama yaklaşımlarının dinamik bir ortamda çalışmayacağının farkına vardıkları anlamına geliyor. Kullanıcı gruplarına gittiğim diğer insanlar ise tam tersi. Statik yazmayı çok hantal buluyorlar çünkü bazı problem türlerini çözme yaklaşımlarını sınırlıyor.

Dürüstçe söyleyebilirim ki, JavaScript ile C # arasında bir atlama yapıyorum. Şimdi, her iki dilde bilmek ve çalışmak, diğerini bir dereceye kadar etkiler, ancak gerçekte, her birine yazdığım kod diğerinden tamamen farklı görünür. Farklı bir yaklaşım gerektiriyorlar, çünkü temelde farklılar. Bulduğum şey şudur: "Adamım bunu X dilinde yapmak çok zor" diye düşünürseniz, yaklaşımınız muhtemelen biraz kapalı olacaktır. İşte bir örnek, insanlar bir şeyleri yapmanın "Pythonic" tarzı hakkında konuşurlar. Bunun anlamı, Python dilinin bir problemi kolaylaştırmak için çalışmasının bir yolu olduğudur. Başka bir yolla yapmak genellikle daha zor ve daha zahmetlidir. Bir dilin nasıl çalıştığını gerçekten sizin için işe yaradığını bilmenin zorluğunu aşmalısınız. O'

Son zamanlarda sorulan benzer bir soru vardı: Dinamik vs Web siteleri için statik olarak yazılmış diller

Cevabımın özünü yeniden yazmak için:

Sistemler büyüdükçe, statik olarak yazılmış diller bileşen düzeyinde sağlamlık ve böylece sistem düzeyinde esneklik sağlar.

Evet, Java kesinlikle yazılmıştır ve evet, Java berbattır (alınma
Ancak, bu çıkarımdan dolayı, katı tip sucks berbat bir yanlıştır. PHP'ye işaret etmek ve dinamik yazım yapmaktan berbat suratlar yapmak gibi (yine, alınma. Yavaşça gelişiyor, sana bunu veriyorum).

Şahsen, gelişimimin çoğunu statik tip sisteme sahip olan haXe'de yapıyorum . Sadece Java'dan çok daha anlamlı değil, tür çıkarımı nedeniyle daha az çaba gerektiriyor, aynı zamanda isteğe bağlı. Hiç yolunda olursa, sadece atlarsın.

Tip güvenliği, kendinizi ayağınıza vurmayı engellemenize yardımcı olacak bir özelliktir (bu, yüksek seviyeli dillerin doğru gelmemesi gereken bir şeydir) .
Ve dinamik olarak yazılmış herhangi bir başarılı dil hakkında, kod türünüzü istediğinizi kontrol ettirme seçeneğine sahipseniz, daha iyi olurdu.
Örneğin, Ruby'yi kesinlikle denemekten zevk aldım, ama bunun nedeni Ruby'nin tamamen nesne yönelimli olmasıydı, çünkü derleme zaman tipi bir sistemin varlığına tamamen dikti.

Bence statik tip sistemlerin tıkayıcı olduğu iddiası sadece iyi statik tip sistemler konusundaki bilgi eksikliğine dayanıyor. Doğru yapan, onlardan biri olan ve belki de en iyisi bile olmayan birçok dil var.

Örnek haXe kodu:

class Car {
    public function new();
    public function wroom() trace('wroooooooom!')
}
class Duck {
    public function new();
    public function quack(at) trace('quackquack, ' + at + '!')
}

function letQuack(o) o.quack();
letQuack(new Car());
letQuack(new Duck());

Bu bir derleme zamanı hatası üretecektir:

Car should be { quack : Void -> Unknown<0> }
Car has no field quack
For function argument 'o'
Duck should be { quack : Void -> Unknown<0> }
Invalid type for field quack :
to : String -> Void should be Void -> Unknown<0>
For function argument 'o'

Gerçekten güvenlik için çok çaba sarf ettiğimi iddia edemezsin.

Güvenlik türüne ihtiyacınız olmadığını söyleyin, çünkü testleriniz daha aptalca. Test yazma sıkıcı ve tekrarlayıcıdır. Ve gerçekten bir test yazmak istemiyorum, sadece bulmak için, bir Car örneğinin kaçmayacağını ve bir Ördeğin kaçmak için birilerine ihtiyaç duyduğunu görmek için.

Günün sonunda, baş üstü güvenlik size ne kadara mal olursa olsun, sonunda amorti edildiğini göreceksiniz (Java'da bile - belki de yakında olmasa da).

Sebep ne olursa olsun, artık bir nesnenin türü ile ilgili hata yapmıyorum. C # gibi dillerde, çalışma zamanı yayınlarıyla ilgili hatalar yapma ihtimalim daha fazladır, genellikle belirli bir zamanın statik olarak çalışmasına ihtiyaç duyduğumdan kaynaklanan, derleyici tarafından algılanabilir bir tür güvenlik hatası yapma ihtimalim vardır. Yazılan dil Yakut yazdığımda, kod bir nesnenin türünde oldukça güçlü ipuçlarına sahip olma eğilimindedir ve bir REPL'in kullanılabilirliği, istenen yöntemin / özelliklerin var olduğunu deneysel olarak doğruladığımı ya da yapılan bir birim testini yapacağımı gösterir. temelde aynı şey, bu yüzden de nadiren yakutta tip güvenlik problemleriyle karşılaşıyorum.

Ancak, statik olarak yazılmış sistemlerin olduğundan daha iyi olamayacağı söylenemez.

Statik olarak yazılmış dillerde, tür sistemi aslında çok da önemlidir. Örnek olarak, işlevsel dillerde Bazı monad gibi bir şeyle (tip <Some>: = yes x | no), çoğu tip sistemde yaygın olarak kullanılan korkunç NullReferenceException; örüntü eşleme kodu çalıştığında, boş koşulu yerine getiremediğinizi bildiren derleme zamanı hataları alırsınız (eğer türünü bildirmek için bu mekanizmayı kullanırsanız). F # 'daki |> pipeline operatörü gibi şeyleri kullandığınızda da benzer hataları azaltırsınız.

Hindley-Milner statik yazım geleneğinde, bir türün X arayüzünü desteklediğini iddia etmekten çok daha fazlasını veren şeyler inşa edebilirsiniz ve bu şeylere sahip olduğunuzda, statik olarak yazılmış sistemin çok fazla olduğunu söyleyebilirim. daha değerli.

Bu bir seçenek olmadığında, C # 'a göre Design By Contract uzantıları, statik tip sistemin değerini artıran başka bir mekanizma kümesi ekleyebilir, ancak yine de bu fonksiyonel paradigmaların bazılarından daha fazla disiplin gerektirir.

Değişir.

İnsan başarısızlığı modları genellikle istatistikseldir. Güçlü tip kontrolü, birkaç insan tipi başarısızlık olasılığını azaltır (buggy koduna neden olur). Ama sadece başarısız olman her zaman senin istediğin anlamına gelmez (Murphy dayanılmaz).

Potansiyel arıza olasılığındaki bu azalmanın maliyete değip değmeyeceği, maliyete bağlıdır.

Bir nükleer santral veya ATC sistemi için kod yazıyorsanız, herhangi bir insan arıza modu azaltması çok önemli olabilir . Spesifik olmayan ve sıfıra yakın başarısızlık sonucu olmayan bazı web sitesi fikirlerini hızlı bir şekilde prototip ediyorsanız, başarısızlık modlarında veya olasılıklarda azalma size bir şey satın alabilir veya almayabilir, ancak geliştirme sürecinde size maliyet getirebilir (daha fazla tuşa basma vb.), ve beyin hücrelerinde, gereken mevcut tip (ler) i ezberleyerek rahatsız etti.

Lisp'te yazılmış birçok karmaşık sistem vardı ve hiçbir Lisper'ın statik yazı yazmak istediğinden şikayet etdiğini duymadım. Onunla çalıştığımda, beni statik bir tip sistemin (ve Common Lisp'te statik olarak tipler belirleyebilirsiniz) yakalayacağı kadar yavaşlatan herhangi bir problemi hatırlamıyorum.

Dahası, ana akım statik olarak yazılmış diller hataları yakalamak için uygun görünmüyor. Bir düzeni tasarlarken, önemli olan belirli sayıda öyle olmasın, sayfada bir dikey ölçüm olmasıdır int, unsigned, float, veya double. Öte yandan, derleyici, genellikle güvenli olmadığını düşündüğü dönüşüm türlerini işaretler ve mutlulukla dikey bir ölçüm ve dizedeki karakter sayısını eklememe izin verir. Statik tip sistemin bu zayıflığı, çirkin işe yaramazlığa bastarize edilmeden önce, Simonyi'nin Macar gösteriminin arkasındaki özgün fikirdi.

Tipler, arayüzler üzerindeki kısıtlamalardır, bu nedenle birim testleriyle test etmek isteyebileceğiniz şeylerin bir alt kümesidir ve bu yüzden birçok alışveriş benzer.

• Statik türler, kodun, asgari düzeyde işlevsel bir şey (müşteri geri bildirimi veya daha üst seviye testler gibi) oluşturmasından geri bildirimini geciktirmek yerine, tür sistemi tarafından ifade edilebilecek gereksinimleri karşılayıp karşılamadığı konusunda daha erken geri bildirim verir.
• Kodun belirli gereksinimleri karşıladığını bilmek yeniden düzenleme ve hata ayıklamayı kolaylaştırabilir, ancak aynı zamanda değişen arayüzlere ve değişen gereksinimlere genel gider sağlar.
• Özellikle, statik olarak yazılmış bir dil zorlamadan yoksunduğunda, hatalara neden olacak verilerde (koşullara ve iddialara duyulan ihtiyacı azaltma) kullanılan kodlara karşı ek güvenlik sağlar, ancak aşırı kısıtlayıcı kısıtlamalar, kullanıcının verilerini masaj yapmak için daha fazla kod yazmasını gerektirir. kabul edilebilir form (açık tip döküm gibi).
• Açık tür ek açıklamaları, kodu okurken anlaşılmaya yardımcı olabilir veya gereksiz veya gereksiz bilgilerle birlikte kod karışıklıklarına neden olabilir.
• Uygulamaya bağlı olarak, durgunluktan kurtulabilir. Bu, tip ek açıklamalarının gerekli olup olmadığı veya çıkarımı gibi olması, tip sisteminin genel tipler / arayüzleri ne kadar iyi ifade edebileceği ve tip sistemi tarafından ifade edilebilecek kısıtlamaları test etmek isteyip istemediğinize (yani, Aynı sınav, bir dil sınavı için bir sınavdan ziyade bir dil özelliği olarak görülebilir, ancak bunu denemek istemeyebilirsiniz).
• Ek olarak (ancak TDD ile ilgisi yoktur), statik tipler derleme zamanı optimizasyonuna yardımcı olabilir, bu tiplerin kontrol edilmesini isteme pahasına (ve onları kontrol etme ve optimizasyonları gerçekleştirme zamanını alır) ve veriler tiplerle sınırlıysa daha iyi optimizasyon yapılabilir bu donanım için iyi bir harita. Bu, performans gereklilikleri ile kod geliştirme işlemini kolaylaştırır, ancak bu kısıtlamalara tam olarak uymayan kod için sorun yaratabilir (madde 3 uyarınca).

Özetlemek gerekirse, dinamik dillerin prototipleme için özellikle faydalı olduğunu savunuyorum, ancak kodunuzun doğru olduğundan emin olmanız gerekiyorsa, güçlü bir tür sistem tercih etmeniz gerekir.

Evet kesinlikle. Hem yazdığınız dilleri hem de Python'u (Python yazdığınız) daha çok kullandığınızda bulacağınız bir şey daha çok dinamik dillerdeki iyi yazılmış kodun, yine de kesinlikle aynı şekilde yazılan kodlarla aynı kuralları takip etmesidir. Dinamik yazma, serileştirme ve seri kaldırma için çok kullanışlıdır, ancak diğer birçok şey için, gerçekten pek bir avantaj sağlamaz. Ve kodunuzun çoğu serileştirme ile ilgili değilse, neden ücretsiz hata kontrolünü atmalısınız?

Morgan, denemeniz için ilginç bir fikrim var: statik + dinamik yazma. Python, C # ve Java'dan bahsettiniz. Hem .NET hem de Java için oldukça iyi Python bağlantı noktaları bulunduğunu biliyor muydunuz? Her iki durumda da, portlar bu platformların kütüphanelerini kullanmanıza ve / veya mevcut kodla birlikte çalışmanıza izin verir. Bu size birkaç olasılık sunar:

1. Eski kodu statik, esnek olmayan bir dilde tutun. Yeni şeyler için Python kullanın.
2. Olgun şeylerin üzerine yeni şeyler prototip yapmak için Python kullanın. Daha olgun bir dilde tutmak istediğiniz bileşenleri tekrar kodlayın.
3. Sık sık değiştirdiğiniz bölümler için dinamik dili kullanın.
4. Çalışan kodu değiştirmek gibi fikirlerle oynamak için dinamik dili kullanabilirsiniz.
5. Dinamik dilde, yazılan dili kullandığınız kritik kısımlar dışında her şeyi yapın.

Bu yaklaşımları, 90'ların sonlarına kadar, C / C ++ 'da gelişmenin acısını çözmek için kullandım. Yerel kütüphanelere ve bazen de performansa ihtiyacım vardı. Yine de, daha iyi sözdizimi, esneklik, güvenlik vb. İstedim. Böylece, hile dikkatlice doğru takasları elde etmek için birleştiriyordu. Uygulamada tüm dili ve eski kodu başka bir dil / platform için kullanmaktan daha iyi bir uygulama oldu.

(Not: Çoktan bir cevap zaten söylemişti, ama aynı zamanda dinamik yazmaya da vurgulamak istiyorum! = Hayır / zayıf yazma. Bir çok dinamik yazma sistemi, içlerinde güçlü yazma işlemini kullanır. değişkenler türü çalışma zamanında belirlenir, tür ek açıklamasına gerek duymaz ve / veya çalışma zamanında değişebilir.

Buna gerçekten nesnel bir cevap alamayacaksınız, ancak benim deneyimim TDD'ye hakim olana kadar tip güvenliğin paha biçilemez olduğudur. Ağır ünite testi kapsamına sahip olduğunuzda, testlerin koddan önce yazıldığı yerde, derleyici denetimi bir acıya dönüşür ve aslında yolunuza girmeye başlar.

Bu sorunun çok fazla olduğunu görüyorum ve yazılım kalitenizin (ve böcek eksikliğinin) geliştirme sürecinizle, sisteminizin nasıl yapılandırıldığını ve sizin ve meslektaşlarınızın kaliteyi kodlama taahhüdüyle daha fazla ilgisi olduğunu düşünüyorum.

Son işim çoğunlukla piton gelişimi oldu. Büyük, uluslararası bir web hosting şirketi için çalıştım ve ABD, Kanada ve Güney Kore'de dev ekipler vardı. Kullanıcıların etki alanı adlarını ve web barındırma hesaplarını yönetmelerini sağlayan ön uç müşteri uygulaması için özel python web çerçevesi. Arka uç: hepsi python da. Python web servisi, yeni bir web barındırma sitesi sağlama, yeni bir blog oluşturma, ad hizmeti sistemimizde dns girişleri oluşturma; etc, vb. Mevcut işimde müşteri hepimizi java'da kullanıyor; ana ürünümüz java ve flash karışımıdır. Eski uygulamalarımız için özel java web çerçevesi, yeni dahili araçlarımız için küçük kapı.

Her ikisinde de çalıştıktan sonra, bu sorunun her gördüğümde beni rahatsız ettiğini söylemek zorundayım. Dinamik olarak yazılmış bir dil kullanıyorsanız ve kodunuzu gerçekten test ediyorsanız, iyi olacaksınız. Sistem iyi tasarlanmışsa ve standartları takip ediyorsanız, iyi olacaksınız. Derleyici denetleme türlerinin bulunmamasından dolayı hiçbir zaman bir hata olmadı. Çoğu hata, tıpkı bugünkü java işimdeki gibi, mantıklı hatalardı.

Tip güvenliği, geliştirme ve esneklik hızını arttırmaya değer midir? NEDEN?

Statik yazım, yazılımın kullanım ömrü boyunca gelişim hızındaki ve esnekliğindeki net bir artıştır . Toplam çabayı ve rahatsızlığı azaltır, ancak daha fazla dikkat çeken, çok fazla çaba ve rahatsızlığı ön plana çıkarır. Çalışma koduna sahip olmak için giriş engeli daha yüksektir, ancak bir kez bu engeli aşınca (tip denetleyicisini sağlayarak), bu kodun uzatılması ve sürdürülmesi çok daha az iş gerektirir.

Yazılım geliştirmede her zaman bazı sıkıntılar olacaktır:

• Neyi başarmaya çalıştığınızın doğasının karmaşıklığı

• İnsanların doğal yanılabilirliği, özellikle daha karmaşık bir şey yapmaya çalıştığımızda daha fazla hata yaptığımızı göz önünde bulundurarak

Er ya da geç, bu zorlukların üstesinden gelmek için biraz zaman ayırmanız gerekir. Bunun etrafında bir şey yok. Statik yazım, bu zorlukları daha sonra değil, en kısa sürede çözer. Er ya da geç daha iyidir, çünkü ne kadar sonra bir hata keşfederseniz ( eğer bir soru değil , ne zaman ), bu hatayı düzeltmenin maliyeti de artar .

Bir tür denetleyicisi tarafından bildirilen bir hatayı düzeltmek, çalışma zamanında ortaya çıkan türle ilgili bir istisnada hata ayıklamanın maliyetinden daha düşüktür. Çalışma zamanına göre tip kontrolünü ertelemek, sadece halının altındaki sorunu taramaktır.

Bu sadece benim görüşüm, ama hayır, bu tip güvenliğin buna değeceğini sanmıyorum. Bir saniye bile değil.

Uzun zamandır geliştirici oldum. C ++, c # ile başlayarak, daha sonra javascript'e taşındı (ön uç ve arka uç node.js). Javascript'te geliştiğimden beri, üretkenliğim aslında tür tabanlı dilleri kullanarak daha da kötüleştiğim bir noktaya geldi. Ayrıca derlemeye karşıyım, şimdi her şeyin çalışma zamanında olmasını istiyorum. Yorumlanmış diller gerçekten programlama sevgimi bulduğum yer.

Türler kadarıyla, hiçbir fayda göremiyorum. Türleri şimdi anlıyorum aynı şekilde bellek yönetimi. Tamamen gereksiz. Yarının dilleri, geliştiriciyi türler hakkında bir şey bilmekten tamamen korumalıdır. Bilgisayar türleri anlamalı ve geliştiriciyi bunun dışında bırakmalıdır.

İşte bir örnek. Sadece bir gün önce ismini bulacağını umarak Swift (Apple'ın yeni dili) kullanıyordum ve yapmaya çalıştım: var n = 1/2 işe yaramadı. Gibi oldu, burada neler oluyor. ve sonra ne yazık ki anladım ki var n: Float = 1/2. Bu bana tip sistemlerden ne kadar nefret ettiğimi ve ne kadar gereksiz bir ağırlaştırmanın hatırlattığını hatırlattı.

Hatta kullanıcı tanımlı türler bile (Sınıflar gibi) istemediğimi söylemek için bir mil daha kullandım. Ben hiç tip istemiyorum. Tek istediğim var ve nesneler. Herhangi bir nesnenin herhangi bir nesne olarak kullanılabileceği yer. Ve nesneler dinamik ve sürekli değişiyor. Neyin işe yarayıp yaramadığına dair bir çalışma zamanı sorunu olduğunda.

Geliştiriciler ne kadar gevşek yazılmış dillerin büyük projeler için iyi olmadığını söylemeye bayılır. Ama bunun tam tersi olduğunu söyleyebilirim. Güçlü yazılmış diller, büyük projeler için korkunçtur. Javascript’in büyük projeler için çalışmadığını söylerseniz, Uber’e node.js / javascript veya PHP ile başlayan Facebook’ta çalışan her şeyi çalıştıran 40 milyar dolarlık bir şirketten isteyin.

Statik olarak yazılmış dillere gelince, bugünün hızlı yinelemeleri için iyi değildir. işte basit bir örnek: .net projesinde sürekli bir entegrasyon sunucusuyla çalışan 10 geliştiriciniz var, bir geliştirici bir hata veriyor ve 10 geliştirici şimdi durdukları ve bekledikleri farklı şeyler üzerinde çalışsalar da tüm yapı bozuldu saldırgan geliştiricinin hatasını düzeltmesi için. Verimli ha hakkında konuşun? Yazma sistemi / statik diller bu şekilde birbirine bağlıdır ve kodunuzu birbirine bağımlı yapar. Ancak, komut dosyaları hiçbir zaman birbirine bağımlı değildir. Komut dosyalarından birinde bir sorun varsa, üretimi durdurmaz, göreceğiniz tüm sorunlar çalışma zamanına bırakılır. Ve çalışma zamanı asla durmaz. Asla kırılmaz. Yanlış çıktı üretebilir, ancak üretmez

EVET.

Java ya da C # gibi tiplerin "güçlü" olmadığı PHP uygulamalarında çalıştım. Genelde "benzetme türlerini" bitirdim, çünkü hatalı otomatik dönüşümleri önlemek veya verileri doğrulamak için.

Dinamik Tip Dilleri, işletim sistemi komut dosyaları ve hızlı küçük uygulamalar için iyidir.

Özet: Bir "Zayıf Tipi" ya da "Dinamik Tip" Programlama dili veya karmaşık işletme uygulaması için bir "Güçlü Tipi" Programlama dili arasında seçim yapmak zorunda, ben seçmek "Güçlü Tipi" Programlama dili .

Geri adım atmanın ve dinamik yazmanın ne zaman sorun yarattığını düşünmemiz gerektiğini düşünüyorum.

Bir durum, bir kod dalının hiç test edilmediği, ancak açık bir şekilde hiç test edilmemiş olan kodun, dinamik yazmanın kullanımda olup olmadığına ilişkin bir sorunlu olması muhtemeldir.

Başka bir daha ince problem olsa da kusurlu ikame edilebilirlik.

Bir tür sadece tamamen yanlışsa, o zaman hızlı bir şekilde algılanması muhtemel olan belirli bir kod yolu hiç kullanılmamışsa.

Öte yandan, bir tür kusurlu bir ikame ise, kod çoğunlukla işe yarayabilir, ancak daha sonraya kadar tespit edilmeyecek ince yöntemlerle bozulabilir.

Programlamada en yaygın türlerden ikisi sayılar ve dizelerdir. Birçok dinamik dilde bunlar birbirleri için kusurlu ikame edicilerdir. Diyelim javascript veya php bir dizgenin beklendiği bir sayı sağlarsanız veya bunun tersi olursa, programınız bir hataya neden olmadan çalışır ancak daha ziyade ince şekillerde yanlış davranabilir.

Python, belirli bir problemin, sayıların ve dizgilerin hiçbir şekilde birbirinin yerine geçmediğinden ve diğerinin beklendiği yerlerde kullanmaya çalışmanın normalde hızlı başarısızlığa yol açacağından kaçındı.

Ancak, kusurlu sürdürülebilirlik probleminden tamamen uzak durmadı. Farklı sayı türleri birbirleriyle kusurlu ikame ediciler olabilir, bu nedenle farklı dizi tipleri olabilir.

Buraya geldiğimde, statik ve dinamik yazmanın yararlarını ve maliyetlerini genel bir şekilde karşılaştırmanın mümkün olmadığını düşünüyorum, çünkü hem faydaların hem de maliyetlerin, bir dilin statik veya dinamik yazmanın belirli bir varyasyonuna bağlı olduğunu düşünüyorum. kullanır.