Dinamik yazmanın varsayılan verimlilik kazancı nedir? [kapalı]


82

Dinamik olarak yazılmış dillerin statik olarak yazılmış dillerden daha verimli olduğu iddiasını sık sık duydum. Bu iddianın sebepleri nelerdir? Konfigürasyon konvansiyonu, fonksiyonel programlama kullanımı, gelişmiş programlama modelleri ve tutarlı soyutlamaların kullanılması gibi modern kavramlarla donatılmıyor mu? Kuşkusuz, daha az karışıklık söz konusudur çünkü (örneğin Java’da) çoğu zaman yedekli yazı tipi bildirimlerine gerek duyulmaz, ancak statik yazımın diğer avantajlarını kaybetmeden, yazı tipi çıkarımı kullanan statik olarak yazılan dillerdeki çoğu yazı tipi bildirimlerini de ihmal edebilirsiniz. Bunların hepsi de Scala gibi statik olarak yazılmış modern diller için geçerlidir.

Öyleyse, dinamik modelleme ile üretkenlik için söylenecek ne var ki bu gerçekten model modelin kendisinin bir avantajı mı?

Açıklama: Büyük / orta ölçekli projelerle hızlı kesmelerden daha çok ilgileniyorum. :-)


10
"Statik ikili" nin "dinamik ikili" den daha hızlı veya daha üretken olmasını bekler miydiniz?
Steve314

İkili ile ne demek istiyorsun? Yine de: Statik yazmanın dinamik yazmadan daha verimli olmasının birkaç nedeni olduğunu düşünebilirim: daha fazla derleyici hataları denetler, kod tamamlama, koddaki programcının amacı hakkında daha fazla bilgi edinir. Bu yüzden sohbeti soruyorum.
Hans-Peter Störr

11
Bu bir şakaydı. "Dinamik ikili" Batman ve Robin. “Statik ikili” olarak adlandırılırlarsa, Gotham Şehri suçlu yeraltı dünyasına neredeyse hiç korku salmazlardı. Geliştiriciler insan olduklarından, yüzeysel şeyler, terimlerin ne anlama geldiğine bakılmaksızın bir fark yaratabilir.
Steve314

İlk sorum, ne yaptığımı bilip bilmediğimdir. Bunu yaparsam, zamanından önce işleri tasarlayabilirim ve statik yazım mantıklı gelir. Eğer yapmazsam, o zaman anında birçok şeyi değiştirmek zorunda kalacağım ve dinamik yazma daha kolay olacak. Common Lisp, ne yaptığımı bilmediğimde bulduğum en iyi dil. (Caveat: Sadece Haskell'i çizdim ve bu nedenle çıkarımsal statik yazım için iyi bir hisim yok.)
David Thornley

2
John Skeet ile tamamen katılıyorum msmvps.com/blogs/jon_skeet/archive/2009/11/17/…
kullanıcı

Yanıtlar:


99

Aslında oldukça yakın bir arama olduğunu düşünüyorum. Hem dinamik yazma hem de statik yazma avantajları vardır.

Dinamik yazmanın nedenleri daha üretken olmak:

  • Daha özlü - Eğer her şey dinamik olarak yazılırsa, çok fazla dış kaynaklı kazan kodu çıkarılabilir - açıklamalar yazın, yazım mantığı vs. yazın sürdürmek (ne olduğunu kavramak için birçok kod sayfasını taramanız gerekmediğinden)
  • Ördek yazma ve maymun yamalama gibi "kesmek" teknikleri daha kolay sonuçlar almanızı sağlayabilir (ancak daha sonra sizi şaşırtabilir ...)
  • Daha etkileşimli - dinamik yazma, hızlı prototipleme, çalışan program örneklerinde gerçek zamanlı hata ayıklama, hatta canlı kodlama için etkileşimli, REPL benzeri programlama için tartışmalı olarak daha uygundur.
  • Test durumları çalışma zamanı hatalarını yakalayabilir - TDD kullandığınızı veya en azından iyi bir test odasına sahip olduğunuzu varsayarsak, kodunuzdaki tüm yazım sorunlarını bulmanız gerekir.
  • Daha iyi polimorfizm - dinamik dillerin, üretkenliği ve yeniden kod kullanımını artırabilen polimorfik fonksiyonların ve soyutlamaların oluşturulmasını teşvik etme olasılığı daha yüksektir. Örneğin Clojure, birçok soyutlamasında dinamik polimorfizmi çok kullanıyor .
  • Prototipler - prototip tabanlı veri / nesne modelleri benim görüşüme göre, statik olarak yazılmış miras heirarchilerinden daha güçlü ve esnektir. Javascript harika bir örnek olarak, dinamik dillerin prototip tabanlı bir yaklaşıma izin vermesi veya teşvik etmesi daha muhtemeldir.

Statik yazmanın nedenleri daha üretken olmak:

  • Daha iyi tasarım - yazılımınızdaki değer türlerini düşünmeye zorlamak sizi daha temiz ve daha mantıklı çözümlere doğru götürebilir. (Ben yapabilirim - gerçekten kötü kod tasarlamak hala mümkün ...)
  • Daha iyi derleme zamanı denetimi - statik yazma, derleme zamanında daha fazla hataya neden olabilir. Bu büyük bir avantajdır ve genel olarak statik olarak yazılmış diller hakkında tartışmasız en iyi şeydir.
  • Otomatik tamamlama - statik yazma, IDE'ye daha fazla bilgi verebilir, böylece kodun veya dokümantasyon aramanın otomatik olarak tamamlanması daha etkili olur.
  • Hack'lerin cesaretini kırıyor - tür disiplinini kodunuzda tutmalısınız, bu da uzun vadeli bakım için bir avantaj olabilir.
  • Tür çıkarımı - bazı dillerde (örneğin Scala) bu, dinamik dillerin özlülük avantajlarının çoğunu hala tür disiplini sürdürmeye devam ettirmesini sağlayabilir.

Ortalama olarak benim sonucum (çitin her iki tarafında uzun yıllar süren deneyimlerden sonra), kısa sürede dinamik yazmanın daha verimli olabileceği, ancak çok iyi test takımları ve test disiplini almadığınız sürece sürdürülmesi zorlaşıyor.

Öte yandan, genel olarak statik olarak yazılmış yaklaşımları tercih ediyorum, çünkü doğruluk faydalarının ve araç desteğinin uzun vadede daha iyi verimlilik sağladığını düşünüyorum.


14
+1, çok ayrıntılı cevap. "Daha iyi derleme zamanı denetimi" noktasının değeri yeterince vurgulanamaz.
NoChance

8
Tür Çıkarımı ile birlikte, Haskell tarzı aşırı yükleme, C ++ şablonları, jenerikler ve statik bir yazım çerçevesindeki Ördek yazmanın avantajlarından bazılarını sağlayan bazı diğer dil özellikleri de var - nesne gerekli arayüzü sağladığı sürece (bu "Bir ördek gibi quacks"), neredeyse o nesnelerin nominal tipine bakılmaksızın kullanabilirsiniz . "Neredeyse", bazı yaklaşımların bir nevi "bu tip ördeğin" ördek gibi düştüğünü "bildirmesini gerektirdiği içindir - örneğin Haskell'deki" sınıf "bildirimi.
Steve314

45
"Kısa kodun okunması ve bakımı daha hızlı olduğu" iddiasına kesinlikle katılmam gerekiyor. Kodu anlamada orta bir adım var . Delphi ve JavaScript’te diğer kişilerin kodlarını korumam gerekiyordu ve Delphi kodunu anlamak çok daha kolay çünkü daha ayrıntılı. Ve en önemlisi, çünkü Delphi kodunun tip bildirimleri var ve JavaScript yok. İlkellerden daha karmaşık bir şeyle uğraşırken, tür bildirimleri değişkenlerinizin ne olduğunu ve neler yapabildiklerini, bakım çalışmaları için gerekli olan bilgileri görmeyi önemsiz kılar.
Mason Wheeler

21
Burada verilen sebeplerin çoğuna katılmıyorum. Muhtemelen en katı tip sisteme sahip olan Haskell'i ele alalım. Bir REPL'e (aslında en az iki) sahiptir, inşaatçılar üzerinde desen eşleştirmesi yaparak çok güçlü bir polimorfizm barındırır ve ümit edebileceği kadar özlüdür - Javascript veya Python'dan çok daha fazlası. Bu yüzden, bahsettiğiniz nedenlerin bir kısmının gevşek yazılmış dillere özgü değil, yanlışlıkla olduğunu tahmin ediyorum.
Andrea,

15
"Test davalarına" çok fazla güvenmezdim. Onları iyi bir tip sistemle karşılaştıramazsınız. Bir tip sistem, fonksiyonunuzun zaten en azından doğru tip parametrelerle çağrıldığının bir kanıtını sunarken, test durumları yalnızca deneysel kanıtlar sağlayabilir. Oysa bu kanıt bile yapay bir ortamda toplanmaktadır.
Ingo,

56

Dinamik dillerle, crappy kodunu yazdığınız dili kullanmaktan daha hızlı yazabilirsiniz.

Devasa dinamik malzemelerinizi çabucak yarattıktan sonra, uzun süreli bakımı önemsemeden güvenle başka bir projeye geçebilirsiniz.

Bu verimlilik kazancı :)

Şaka yapıyorum, ancak 'dinamik dil' kullanan bir projeye dahil olduktan sonra, çalışan bir ürün almak istiyorsanız uğraşmanız gereken gereksiz testler, belgeler ve sözleşmelerden korktum.
Ve derleme sırasında yakalanabilecek birçok çalışma zamanı hatasının neşesi ile.
Ayrıca, meta-programlama kodunuzu tanıtmak için izin bu tüm kesmek ve voodoos hakkında rant için unuttum!

Dolayısıyla verimlilik kazanımı, ömrü boyunca orta / büyük proje için bir efsane olabilir.


11
Evet, deneyimim aynı. 100 satırlık bir perl betiği tamamdır ve böyle harika araçlar olmadan kaybolmuş oluruz. Ancak 100k hat perl projesi büyük olasılıkla bir kabus olacaktır.
Ingo,

3
... ve sonra JavaScript'iniz var (sadece dinamik değil, aynı zamanda zayıf yazılmış).
Den

16

Bu soruna da teorik bir bakış var: Statik tip bir sistem, esasen, sadece programın doğruluğunu ispat edince programı kabul eden uzman bir teorem ispatcısıdır. Tüm statik tip sistemler bazı geçerli programları reddederler çünkü reddedilebilir statik tip sistem olası tüm doğru tip programları kanıtlayacak kadar güçlü değildir.

Bir kimse, statik bir bilgisayar denetleyicisi tarafından kanıtlanamayan programların bilgisayar korsanları ve / veya kötü bir stil olduğunu iddia edebilir, ancak zaten geçerli bir programınız varsa ve bilgisayar çalışanı bunu kabul etmiyorsa, kısa vadede verimliliğinizi kesinlikle bozmaktadır.

Tip denetleyicisinin girdiğini fark edebileceğiniz bazı durumlar, argümanlar ve dönüş türlerinde genel kapsayıcılar ve eş / karşıtlık ile ilgilidir.


18
Eğer yanlışlıkla bir girdiniz Tersine eğer yanlış programı derleyici derhal bildirir ve kötü çizgi vurgulanır. Bu, başarısız bir test çalıştırması fark edip hatayı bulmak için hata ayıklamakla karşılaştırıldığında verimliliğinizi artırır.
MarkJ

5
jenerik kaplar ve açık bir eş / karşıtlık, yanlış yaparsanız "yolunuza girme" anlamına gelmektedir. çalışma zamanında başarısız olacak kod derlemenin faydası nedir?
M.Stramm

Genellikle, tüm testleri başarıyla yürütene kadar% 0 iş yapılır. Ancak o zaman gelişiminiz hiçbir şeyden daha fazla düşünülemez. Bunu akılda tutarak, henüz bitmemiş bir şeyde verimliliğini ölçmeye değeceğini sanmıyorum.
Pijusn

-1 Asıl soruya değinmiyor ("verimlilik kazanıyor", hatırladın mı?) Ayrıca, muhtemelen "sistemlerin reddettiği tipte programlar" yazmayı da istemezsiniz. Sırf yapabileceğin anlamına gelmez. Ve neden typechecker'ın reddettiği "geçerli bir program" a sahip oldunuz? Ne, bir Javascript programını kodluyor ve aniden onu Java'da derlemeye çalışıyor muydun?
Andres F.

Yazım sisteminin reddettiği geçerli programlar, kodunuzu kısaltmanıza yardımcı olabilir, bu nedenle, yazım sisteminin çözemediği hataların azalmasına neden olabilir (daha az kod = daha az hata). Çizgiyi vurgulayan derleyici / IDE, test değerleriyle (yani REPL odaklı geliştirme) dinamik dillerde yapılabilir, böylece ara değerleri görebilirsiniz ve yazım sisteminizin yazamadığı hataların yanı sıra yazım hatalarını da alabilirler. Ayrıca, size tip uyarıları vermek için statik tip çıkarımı da kullanabilirsiniz.
aoeu256

15

En dinamik dillerde bulduğum bir avantaj, daha genel kod yazmayı kolaylaştırmalarıdır. Bunu yapmak için tip sistemiyle savaşmanız gerekmediğinde daha yüksek bir soyutlama düzeyinde yazmak çok daha kolaydır.

Bunu düşünmek zorunda değilsiniz - Java'daki herhangi bir nesneyle önemsiz şeyler yapan kod yazmak zordur ve muhtemelen temelde dinamik olarak yazılmış bir yansıma gerektirir; JavaScript gibi bir şeyle birlikte, tüm nesneler için ilginç bir şey yapan bir işlev yazmak ikinci niteliktedir. Mükemmel bir örnek, yakın zamanda yazdığım bir nesneyi alan ve tüm yöntemlerini aynı şeyi yapanlarla aynı zamanda bir olayı ateşleyenlerle değiştiren bir işlev olabilir. Java'da böyle bir şeye nasıl yaklaşılacağı hakkında hiçbir fikrim yok. Ancak, bunun tür sistemlerinden ne kadar kaynaklandığından ve diğer dil farklılıklarından ne kadar kaynaklandığından emin değilim.

Ancak, son zamanlarda Haskell kullanmaya başladım. Haskell, kullandığım dinamik olarak yazılmış herhangi bir dilde olduğu kadar soyut, jenerik kod yazmamı sağlıyor. Benim Java / JavaScript Yukarıdaki örnek kılan hiçbir sayesinde nesnelerin, yöntemleri, etkinlikleri, hatta çok mutasyona sahip olmadığı için Haskell duygusu, ama genel kod diğer türlü gerçekten yazmak kolaydır.

Aslında, Haskell dinamik olarak yazılmış dillerin yazamadığı bazı genel kodlar yazabilir; Mükemmel bir örnek, readtemelde zıt olan fonksiyondur toString. İstediğiniz bir tür Intveya bir Doubleveya ne istersen alabilirsiniz (belirli bir sınıfta olduğu sürece). Hatta polimorfik olabilir sabitleri , bu yüzden maxBoundmaksimum olabilir Int, Double, Char... vb., Bütün bu gerekiyordu türüne bağlı olmak.

Şimdi benim teorim, dinamik bir dil kullanmanın üretkenliğini her zaman daha az yetenekli, daha ayrıntılı ve daha az esnek tip sistemli Java gibi dillerle karşılaştırmaktır.

Ancak Haskell'in tür sisteminin bile dinamik olarak yazılmış bir dilde sahip olmayacağınız can sıkıcı sorunları var. Sinirlendiğim en büyük sayı, sayıların ele alınma şekli; örneğin, lengthbir listeyi (bir listeyi) çift olarak kullanmak için yazım sistemi ile uğraşmanız gerekir, yazım sistemi olmadan sorun yaşamayacaksınız. Karşılaştığım bir diğer can sıkıcı şey, Word8(imzasız bir int türü) ile çalışmak ve beklenen işlevler Int.

Sonuç olarak, hiçbir tür sisteme sahip olmamak, çok fazla düşünmeden genel kod yazmayı kolaylaştırır ve ayrıca tür sistemlerin can sıkıcı tuzaklarından kaçınır. Tip sistemiyle hiçbir zaman dinamik bir dilde savaşmak zorunda kalmazsınız, ancak ona güvenemezsiniz.


1
Evet, bazı nedenlerden dolayı, sayı sistemlerinin doğru olması zor. Scala'da da bir karışıklık. Bence dinamik tip sistemler basit statik tip sistemler üzerinde çalışmayı kolaylaştırıyorlar. Elde ettiklerini düşünüyorum, fakat daha gelişmiş sistemlerden (S-Sistem , Haskell, ML gibi, hepsi sistem-F değişkenlerini kullanan) kaybediyorlar .
Edgar Klerks

3
Cevabınız iyi niyetli ancak hataları var. Birincisi, dinamik dillerin "hiçbir tip sistemine sahip olmadıkları" doğru değil, bu yüzden "genel kod yazmayı kolaylaştırmalarının" nedeni olamaz. Haskell ile kendi karşı örneklerin gösterdiği gibi bunu kolaylaştırmazlar (kendi iddiasını mahrum ettin!). "Tip sistemiyle hiçbir zaman mücadele etmek zorunda değilsin" yanlıştır: yeterli statik statik kontrolün neden olmadığı bir hatayı düzeltmek için her defasında bununla savaşırsın. Son olarak, açıkça Intbir listenin döndürdüğü bir zorlama zor Örnek: 1.0 + fromIntegral (length myList)yani sadece kullanın fromIntegral.
Andres F.

2
Son olarak, "hızlı kod yazma"! = "Daha üretken olmak". Kodunuz çalışmak zorunda! Daha sonra hata ayıklamak ve tamir etmek için zaman harcayacağınız buggy yazılımını yazarsanız, üretken olmazsınız.
Andres F.

"çok fazla düşünmeden", çoğu insanın dinamik olarak yazılmış diller hakkında "daha üretken" olduklarından bahsettiklerinde "kırmızı bayrak" anlamına geliyor
Ataraxia

Eğer tip sistemler gerçekten verimliliği arttırdıysa, Haskell veya Idris'teki faydalı uygulamaların tümü nerede? Bence yazım hatası, "yamalılık" (uygulamanızı öngörülemeyen şekillerde düzenleyebilme yeteneği) ve doktora testlerinde% 90 hata kontrolü yapılması ve yazı çıkarımının daha önemli olabileceğini düşünüyorum.
aoeu256

7

S: Dinamik olarak yazılmış dillerin statik olarak yazılmış dillerden daha verimli olduğu iddiasını sık sık duydum. Bu iddianın sebepleri nelerdir? "

Bunun tarihsel nedenleri var. Birkaç on yıl öncesine kadar giderseniz, dinamik diller tartışılmaz bir şekilde statik dillerden çok daha verimlidir (aynı zamanda önemli ölçüde daha yavaş). Her ikisini de biliyorsanız Perl açıkça C'den çok daha üretkendir ve eldeki göreve de izin verir. Ancak zamanla diller birbirlerinden çok fazla ödünç aldılar ve yeni diller (hem üretkenlik hem de performans açısından) açığı daraltmakta.

İşte dikkat etmeniz gereken bazı noktalar:

Çöp toplama : Çöp toplama büyük bir verimlilik artışıdır. Java’nın GC’yle ilk ana statik dil olduğunu düşünüyorum. Bundan önce, statik temelde manuel bellek yönetimi anlamına geliyordu. (Not: Burada ve aşağıda sadece genel dilleri düşünüyorum. Yaptığım herhangi bir noktaya karşı örnekler verecek birçok deneysel ve niş dil var.)

Bellek güvenliği : Kendinizi ayağınızdan vurmaktan endişe duymanıza gerek kalmaması verimlilik artışıdır. Java gibi statik dilleri "yönetilen" önce, statik genellikle doğrudan bellek erişimi anlamına geliyordu. Hata ayıklama aynı zamanda verimliliğin bir parçasıdır ve güvensiz bellek erişimi gerçekten belirsiz hatalara yol açabilir.

Hantal tip sistemler. Statik dillerde parametreleştirilmiş tiplerin (şablonlar veya jenerikler gibi) kullanılmasından önce, statik tip sistemlerin sınırlamaları genellikle bir yük olmuştur. Örneğin, Java’da, koleksiyondan bir öğe seçtiğiniz her seferde açıkça aşağıya inmeniz gerekiyordu. Yani alçıda sözdizimsel yükü var ve hiçbir tür güvenlik yok. Her yerde bulunan koleksiyonların programlamada ne olduğu göz önüne alındığında, bu önemli bir dezavantajdı.
Her şeyin türünü bildirmek zorunda olmak çok fazla gereksiz yazım olmakla birlikte, modern tür çıkarımı ile bu önemli ölçüde azaltılabilir.

Büyük standart kütüphane. Python, büyük standart kütüphanesi nedeniyle ünlü "piller" olarak ilan edildi. Bu, minimalist bir standart kütüphaneye sahip olan C ile karşılaştırıldığında. Ancak Java ve .net gibi platformlarda geniş bir standart kütüphane standart hale geliyor ve Scala ve F # gibi daha yeni diller bunu "ücretsiz" miras alıyor.

Birinci sınıf veri yapıları. Perl ve Python gibi dinamik diller, ortak işlemler için uygun sözdizimsel kısayolları olan listeler ve haritalar gibi birinci sınıf veri yapılarına sahiptir. Bununla karşılaştırıldığında, C'nin sabit boyutlu diziler dışında yerleşik koleksiyonları yoktur.

Kapanışlar ve lambda sözdizimi - dinamik diller tipik olarak en başından beri olmuştur, fakat statik diller en son Java'yı benimsemiştir.

Kod pasajlarını etkileşimli olarak hızlı bir şekilde test etme yeteneği REPL'in büyük bir nimet olduğunu. Ancak IDE araçları, Visual Studio'daki "acil" pencere gibi, statik diller de bunu bir dereceye kadar taklit edebilir.

Gelişmiş takımlar - statik dillerin dinamik dillerin kolaylığına daha fazla yaklaştığı yukarıdaki noktalara ek olarak, modern editörler dinamik dillerin zor bir zaman eşleşmesine sahip olacak şekilde statik analizden yararlanmaktadır. Örneğin editörler, dinamik bir dilde kesinlikle imkansız konuşan bir şey olan güvenli otomatik yeniden yapılandırmalar sağlayabilir.

Alt satır: Tarihsel olarak doğruydu, ancak bugün cevap daha az kesinti.


S: Öyleyse, dinamik modelleme ile verimlilik için ne söylenebilir?

Dinamik yazım modelini dinamik dilden ayırmak biraz zordur, ancak bir örnek olarak C #, çekirdeği statik bir dil olmasına rağmen, zaman içinde daha dinamik özellikler benimsemiştir. Bu gerçekten dinamik tip modelinin faydasının bir kanıtı. Örnekler:

Yansıma Yansıma, temel olarak dinamik bir yazma özelliğidir. Nesne türlerini çalışma zamanı raterinde derleme süresinden daha fazla denetlersiniz. Sunulduğu zaman kaşlarını çattı, ama C # 'da yansıma kullanımı gittikçe daha yaygın hale geldi, örneğin ASP.Net MVC yansıması yoğun olarak kullanıyor.

Nitelikler Nitelikler, dinamik yazma örneğidir. Derleme zamanında bir sınıfa rasgele özellikler ekleyebilir ve sonra çalışma zamanında (yansıtma yoluyla) denetleyebilir ve nesneleri temel alarak işleyebilirsiniz. MEP gibi bir şey temelde bir dinamik tip modeline dayanan bir uzatma çerçevesidir.

Linq to SQL, EF mv. Çeşitli Linq transformatörleri, sorguları çalışma zamanı nesneleri olarak inceler ve anında sql üretir. Çalışma zamanında kodu denetlemekten daha dinamik olmaz. CodeDom, madalyonun diğer tarafında, çalışma zamanında kodun üretilebileceği yerdir

Roslyn Roslyn bir evalzamanlar gerçekten dinamik bir dilin tanımlayıcı özelliği olarak görülen temelde uygular .

Dinamikdynamic tipi C # en açık dinamik bir özelliğidir ve dış nesneler ve daha basit ve daha üretken dillerle etkileşimi kılmayı bildirilir. Fakat aynı zamanda Asp.net MVC'de kolaylık sağlamak için de kullanılır.

Yukarıdaki özelliklerin tümünün avantajı, dinamik modelin, parametreli hale getirilmiş tipler, yapısal tipler ve tip çıkarımı olan statik bir dilde bile kesin avantajlara sahip olduğunu göstermektedir .


Bu cevabı gerçekten sevmiyorum, çünkü neredeyse bütün noktalar temel soruya değinmiyor, "Dinamik yazmanın varsayılan üretkenlik kazancı nedir?" dinamik diller değil .
dadı

@ nanny, dinamik yazılan diller ve dinamik diller arasındaki algılanan farkınızı açıklayabilir misiniz? (bu bulanık şeylerden biri). Her biri için net tanımların yanı sıra, dinamik bir dil olmayan dinamik bir yazılı dil örneği verebilir misiniz?

@ nanny: Soru aslında sadece "dinamik yazma" değil, "dinamik olarak yazılmış diller" hakkında soruyor.
JacquesB

@MichaelT Üzgünüm net değildim. Dinamik yazma, tüm dinamik dillerin bir yönüdür. Bu cevap, tarihsel olarak, dinamik yazma kısmına değinmeden, dinamik dillerin gelme eğiliminde olduğu diğerlerinden bahsediyor.
dadı

1
@ nanny: Buna temel olarak cevap veriyorum: "Dinamik olarak yazılmış dillerin statik olarak yazılmış dillerden daha verimli olduğu iddiasını sık sık duydum. Bu iddianın sebepleri nelerdir?" - Bu iddianın nedenlerinin sadece dinamik tipleme ile değil aynı zamanda dinamik dillerin diğer verimlilik artırıcı özellikleri ile de tarihsel ve ilişkili olduğuna inanıyorum.
JacquesB

6

Tüm modern dil özelliklerinin tümü o kadar büyük ki, statik ve dinamik yazmanın tek başına fazla ağırlık taşımaması.

Kural şudur, diliniz ne kadar iyi olursa, kodunuz o kadar kısa olur. Bu oldukça basit. Java, statik yazmanın nasıl yanlış gidebileceğini gösterir, bu da rakiplerine beslenmeleri için çok şey verir. Kötü tasarlanmış dil özellikleri genellikle bir maliyetle gelir ve Java'da statik yazım ilk olarak zorunlu bir özelliktir (aksi halde çoğu kişi muhtemelen onu kullanmaz bile) ve ikincisi kötü uygulandı.
Bu nedenle, dinamik dillerin çoğunun parlamasının nedeni, PHP'nin hayatınızı genel toplamda (en azından yakın zamana kadar) gerçekten daha iyi hale getirmediğini iddia etmeme rağmen, tip sistemleriyle ilgisi olmayan diğer tuhaflıklar.

Öte yandan, kendi tarzınıza girmeyen ve hatta zorunlu olmayan etkileyici tip sistemleri olan birçok dile sahipsiniz. Hatta bazıları tür sisteminden kaçmanız gerektiğinde, yazılmamış kodun gömülmesine bile izin verir.

Şahsen ben, her ne kadar arcane sözdiziminden kaçınırken hem nominal hem de yapısal alt tipleme, isteğe bağlı türetilmemiş kod, birinci sınıf fonksiyon tipleri, cebirsel veri türleri ve (oldukça olgun değil ama son derece güçlü) sözlük makroları olan bir dil olan haXe kullanıyorum. Yaklaşık 3 yıldır haXe kullandıktan sonra, basit bir sonuca vardım:

Programlama çok kolaylaşır, diliniz paradigmalar konusundaki dini seçimlere kilitlenmez, ancak iyi bir araç olur. Bunu başarabilen çok sayıda statik ve dinamik dil ve karma dil var. Bazıları öğrenmesi kolay, çoğu ustalaşması zor.
Güçleri, karmaşık özelliklere kolayca basit çözümler üretmek için kişisel özelliklerinin oluşturulma şeklinden kaynaklanmaktadır. Bu, şu ana kadar keşfedilen tüm dil özelliklerinin hassas bir şekilde dahil edilmesi veya yok sayılması dengesi ile elde edilebilecek belirli bir dikliği engellemektedir. Ruby'ye statik yazım eklemeye çalışırsanız, onu sakatlarsınız, Haskell'den uzaklaştırmayı denerseniz ezecektiniz. Bunun aksine: eğer onu C'den aldıysanız, insanlar farketmezdi ve Java'dan aldıysanız bazıları size teşekkür edebilirdi.

Kişisel deneyimimden, size şunu söyleyebilirim: Ruby'yi severim. Ufkumu ve sistemleri tasarlama biçimimi genişletti. IMHO, insanlara programlamayı ilk etapta öğretmek için kullanılmalıdır. Göze çarpmayan, güçlü, özlü, eğlenceli. Ortodoks bir dilden gelen birisinin neden hoşlanacağını anlıyorum.
Ancak uzun vadede statik yazım, işi statik analizöre ertelemeye izin verir ve yazım çıkarımı ile bu temel olarak ücretsizdir. Sonuç, bakımı kolay ve çoğunlukla daha hızlı çalışan koddur.

Fakat yine de, statik yazım tek başına bir şey yapamaz. Bu bir kombinasyon meselesi. F #, Scala, Nemerle, OCaml veya haXe arasında bir yerde kendi idealinizi bulabileceğinizi düşünüyorum. Fakat bu sonuçta size bağlıdır, çünkü dil, düşüncelerinizi çaba sarf etmenize izin vermeli, sizi onları bükmeye zorlamak yerine. Ve sonuçta, hiçbir şey, programlama eğlenceli olduğundan daha fazla üretkenlik kazancı sağlamaz.


"Kural, diliniz ne kadar iyi olursa, kodunuz o kadar kısa olur." Bu, bir düzeyde görüşe bağlı olabilir, ancak bu ifadenin doğru olduğunu sanmıyorum. Daha kısa kod, yazma zamanında daha az yazı yazmaktan ve belki de daha az disk alanı kapamaktan (derlenmiş dillerde zaten bir faktör olmayan) daha fazla avantaj sunmaz. Bence iyi bir dilin işareti, mümkün olan en özlü biçimde ne yaptığı hakkında çok fazla bilgi aktarıyor. Dinamik yazma çok kendi kendini belgelendirmez ve sonuç olarak sürdürülebilirliği kaybeder imo
Ataraxia

Dinamik yazılan kodu, varsayılan değerler / anahtar sözcük argümanları, tür çıkarımından elde edilen türler, bir JIT derleyicisinden gelen dinamik tür çıkarımı veya sadece tüm fonksiyonları günlüğe kaydetme [çalışan bir programdaki her fonksiyon veya sınıfa girip bunları yerine bağımsız değişkenlerini / sonuçlarını kaydeden işlevin sürümü). Sonra bir işlevin önceki işlemlerinin günlüğünü görebilirsiniz. Başka bir fikir, ne tür açıklamaları, çalışma zamanı sözleşmeleri, ne de örnek REPL oturum testlerini içermeyen kodu reddetmek, ancak geliştiriciye üçünden birini seçme seçeneğini vermektir.
aoeu256

3

Kişisel olarak, dinamik tiplemenin yardımcı olacağı tek neden gerçekten yavaş bir daktiloysanız veya gezinmesi zor olan dev fonksiyonlar / yöntemler / whatevers oluşturuyorsanızdır. Ayrıca, tüm birim test sorununa girmeniz gerekiyor. Dinamik tipler gerektirir (bozuk kod yazmayı sevmiyorsanız) güçlü birim testleri (Dinamik tiplerinizin beklenmedik şekilde patlamasını sağlamadığından emin olmak için (ör. Değişken çoğunlukla ördektir, ancak bazen yanlışlıkla dunk). Statik bunu önlemek için çok çaba harcayacaktır (Ve evet, güçlü ünite testleri için tartışma yapabilirsiniz)


0

Sanırım öncelikle "üretkenliği" tanımlamanız gerekiyor. "Verimlilik" ne demek ve içerir?

Eğer "daha üretken" derken aynı özelliği uygulamak için daha az kod satırı yazmayı kastediyorsanız, evet, dinamik yazma programlama dilleri statik yazma dillerinden daha "üretken" olur.

Bununla birlikte, hata ayıklama ve hata ayıklama için harcanan zamanı da göz önünde bulundurursanız, dinamik yazma dilleri o kadar verimli olmayabilir, çünkü dinamik yazma dilleri hata kontrolünü çalışma zamanına zorlarken, statik yazma dilleri Derleme zamanında bazı hata kontrolü yapabilir. Genel olarak kabul edildiğinden, genellikle, bir hata bulunursa, bu hatayı düzeltmek daha pahalı olur. Bu nedenle, dinamik yazma kodu, statik yazma kodundan ziyade, üretkenlikten genellikle eşit veya belki de daha az sonuçlanabilir.


Genel olarak, dinamik bir dil kullanarak daha az satırda bir özellik yazabileceğiniz doğru değildir. Zaten hangi dilleri karşılaştırıyorsun?
Andres F.

@AndresF. Oh, ağırlıklı olarak Python ve C ++ kullanıyorum.
yaobin

1
Tamam, ancak Python ve C ++ ile karşılaştırırken dinamik ile statik arasında genelleştirme yapamazsınız. C ++, statik yazmalı bir dilin özellikle temsili bir örneği değildir. Python'da olduğu kadar kısa programlar yazmanıza izin veren son derece özlü statik yazılmış diller vardır. Yani, genel olarak, iddianız yanlıştır.
Andres F.

Evet, peki ya programın hala çalışır durumdayken düzenlerseniz? Herhangi bir çalışma zamanı sorunu basitçe ortaya çıkar ve bunları tam orada onarabilirsiniz. Lisp'te ne zaman bir hata alırsanız, programınızı düzeltebilir ve daha sonra çalıştırmaya devam edebilirsiniz. ayrıca tip dışı hatalar da olabilir, bu nedenle herhangi bir dilde karmaşık yollardan kaçınmak iyi bir fikir olabilir.
aoeu256

-1

Dinamik yazmanın en büyük avantajı verimliliktir.

Python, Ruby, vb., Dinamik yazmanın yanı sıra (varsayılan parametreler, türler gibi yerleşik sözlükler vb. Gibi) birçok üretkenlik artırıcıya sahiptir. Programcı verimliliğindeki kümülatif etki etkileyicidir.

Hız (veya eksiklik!) Ve kaynak tüketimi gibi cezalar beklediğiniz kadar kötü değildir ve çoğu durumda geliştirme hızı ve esnekliği ile telafi edilmekten daha fazlasıdır.

Konuyla ilgili (çok eski!) Bir makale var. Programcının üretkenliği üzerine yapılan doğru bir şekilde yapılmış az sayıda araştırmadır ve sonuçların çoğu hala geçerlidir.

Bugün yapılacak çalışma neydi (muhtemelen) farklı olurdu: -

  1. Java JVM'leri tanınmanın ötesine geçmiştir.
  2. Modern IDE'ler C ++ ve Java kodlayıcılarının verimliliğini geliştirmiş olacaktı, ancak betik dilleri üzerinde çok az fark yarattı.
  3. C # dahil edilecek ve muhtemelen Java ile aynı top parkında olacak ama biraz daha iyi.

Bu nedenle, bu mesaj performans gerçekten ciddi bir sorun olmadığı sürece, dinamik diller verimliliğinizi artıracaktır.


2
Açıklamam, dinamik yazımın verimliliğinizi arttırmak için yaptığı şeydir. Kağıt ilginç, ancak çok küçük bir programla ilgili ve bunun çoğu programda binlerce satır kodunu nasıl aktardığından emin değilim.
Hans-Peter Störr

5
Bu çalışma yalnızca C, C ++ ve Java'yı statik dil örnekleri olarak kullanır ve ardından genel olarak geleneksel programlama dillerine bulunan sonuçları uygulamaya çalışır. Her üç dil de aynı temel sözdizimi paylaşıyor, aynı içsel, düşebilirlik azaltan kusurları kıyaslayarak geçersiz kılıyor. Statik dillerin üretken olmadığı değil , C ailesinin verimsiz olduğu. Testlerine Pascal lehçesini dahil etselerdi, büyük olasılıkla bazı farklı sonuçlara varacaklardı.
Mason Wheeler

@mason - Bu alanda çok az gerçek objektif çalışma var. Bu, gerçek sayılarla vb. Yapılan gerçek çalışmalardan biridir. "Örnek" programı önemsiz değildir! Sözlük işleme, karmaşık algoritmalar ve büyük veri hacimlerinin unsurlarını birleştirir. Başarısız ve çökme girişimlerinin yüksek yüzdesi, görevin önemsiz doğasını doğrular.
James Anderson

2
-1 Dinamik yazılı dilleri neyin daha üretken kıldığı hakkında pek bir şey söylemiyorsunuz . Varsayılan parametreler ve sözlükler, örneğin Scala gibi statik yazılmış dillerde bulunabilir.
Jonas

1
@JamesAnderson Daha da kötüsü, bağlandığınız kağıtlar amacınızı desteklemiyor bile. "Kodlama dilleri" (genellikle dinamik) " geleneksel diller" (genellikle statik) ile karşılaştırır. Şimdi, söyle bana, "geleneksel" diller tam olarak nedir? Statik yazarak dil grubuyla aynı olduğunu düşünüyor musunuz? Daha da kötüsü, kağıt o kadar eski değil . 2000 yılına gelindiğinde, dinamik dillerden daha tartışmalı bir şekilde daha üretken olan statik yazıya sahip birçok harika dil vardı.
Andres F.
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.