Yukarıdan aşağıya veya aşağıdan yukarıya doğru tasarım tercih edilir mi?


31

Anladığım kadarıyla, yukarıdan aşağıya tasarım, en küçük yapı taşı tanımlanana kadar soyut yüksek seviye konseptini daha küçük beton ve anlaşılabilir parçalara rafine ederek yapmaktır. Öte yandan, aşağıdan yukarıya düşük seviyeli parçaları tanımlar, daha sonra tüm sistem oluşana kadar kademeli olarak daha yüksek seviye blokları oluşturur.

Uygulamada, iki yöntemi birleştirmenin en iyisi olduğu söylenir: alan bilgisini, ilişkisini ve kısıtlamalarını tam olarak belirtmek için yüksek düzeyde spesifikasyonla başlar. Sorun iyi anlaşıldığında, sistemi oluşturmak için en küçük yapı taşları oluşturulur.

Süreci:

  • Gereksinim spesifikasyonu oluşturma
  • Bir tasarım spesifikasyonu oluşturun (diyagramlarla)
  • uygulamak
  • teslim etmek
  • Tekrarlayın (yinelemeli gelişimde, her aşamada bir parça yapmak yerine, her birini tekrar tekrar biraz yaparız ve müşterinin dinamik ihtiyacına uyum sağlamak için günlük toplantı yaparız)

Bana göre tamamen normal görünüyor (özellikleri gibi). Bunun kusurları var ama bu yüzden yinelemeli gelişimimiz var: Bir aşamaya zaman harcamak yerine, olası her şeyi incelemek için alan bilgisinde her şeyi incelemek için ihtiyaç analizi (belki de günlük olarak), biraz analiz yapıyoruz, diyor. biraz tasarım ve sonra uygulayın.

Başka bir yol, her bir yinelemenin, analizin birkaç gün (veya bir hafta) içinde yapıldığı mini şelale modasıdır. Aynısı tasarım için de geçerlidir. Geri kalan zaman uygulama için harcanır. Yinelemeli gelişim ile birlikte yukarıdan aşağıya yaklaşımda doğal olarak yanlış bir şey var mı?

Programlama Bottom Up adlı makalesinde , Paul Graham, aşağıdan yukarıya inşa etmeyi tamamen teşvik ediyor veya aşağıdan yukarıya programlıyor gibi görünüyor, ancak gereklilik analizi / tasarım aşaması:

Tecrübeli Lisp programcıları programlarını farklı şekilde bölerler. Yukarıdan aşağıya tasarımın yanı sıra, aşağıdan yukarıya tasarım denilen bir prensibi takip ediyorlar - soruna uygun dili değiştirmek.

Benim bildiğim kadarıyla, demek istediği Lisper'ın hala yukarıdan aşağıya tasarım yapıyor olması, fakat programın aşağıdan yukarıya doğru olması, doğru mu? Yazdığı bir başka nokta:

Aşağıdan yukarıya tasarımın aynı programı farklı bir sırayla yazmak anlamına gelmediğinin altını çizmeye değer. Aşağıdan yukarıya çalışırken, genellikle farklı bir programla karşılaşırsınız. Tek, monolitik bir program yerine, daha soyut operatörlerle daha büyük bir dil ve programda daha küçük bir program olacak. Bir lento yerine, bir kemer alırsın.

Bu Lisp'te bir program yazarken, genel bir araçla sonuçlandığınız anlamına mı geliyor?


Belki de atıfta bulunduğunuz kitabın, makalenin veya makalenin linkini verirseniz, diğerleri sorunuzla ilgili daha mantıklı bir açıklama yapabilir. Ayrıca, sorunuzun neyle ilgili olduğu belli değil. Uygulamak istediğiniz tasarıma ilişkin bazı özellikler hakkında tavsiyeler veya referansta bulunduğunuz makale hakkında sorular mı soruyorsunuz? Belki ayrı ayrı sorulan birkaç soruya ayırırsanız okumak ve cevaplamak daha kolay olacaktır.
S.Robins

@ S.Robins Özetle, yazılım geliştirmek için her zamanki yukarıdan aşağıya yaklaşımımı gösterdim. Ancak, bazı insanlar aşağıdan yukarıya tercih eder ve bunlardan biri ünlü bir kişi olan Paul Graham. Aşağıdan yukarıya tasarımın genel olarak ve özellikle de Lisp'te teşvik etmek için özel özelliklere sahip olduğu için (Paul'un önerdiği gibi) nasıl yardımcı olduğunu anlamak istiyorum.
Amumu

1
Amumu Örneği düzenledim, çünkü her iki cevap da yine atlamış gibi görünüyor. Lütfen sorularınızı kısa tutmaya çalışın ve soru başına yalnızca bir soru sorun .
yannis

Yanıtlar:


35

Yukarıdan aşağıya, bildiğiniz şeyleri tanımlamanın veya önceden oluşturduğunuz şeyleri yeniden oluşturmanın harika bir yoludur.

Yukarıdan aşağıya en büyük sorun, çoğunlukla basitçe "üst" olmamasıdır. Sistemi geliştirirken ve etki alanını araştırırken sistemin ne yapması gerektiği konusundaki fikrinizi değiştireceksiniz. Başlangıç ​​noktanız bilmediğiniz bir şey (örneğin, sistemin ne yapmasını istiyorsunuz) olabilir?

Bir "yerel" tepeden aşağıya iyi bir şey ... kodlamadan önce düşünmek açıkça iyi. Ancak çok fazla düşünmek ve planlama yapmak değildir, çünkü düşündüğünüz gerçek senaryo değildir (daha önce orada bulunmadığınız sürece, yani eğer inşa etmiyorsanız, ancak yeniden inşa ediyorsanız). Yeni şeyler inşa ederken Global yukarıdan aşağıya sadece saçma.

Aşağıdan yukarıya doğru (global olarak) yaklaşım olmalıdır, sorunun% 100'ünü bilmiyorsanız, kodlanması için bilinen bir çözüme ihtiyacınız var ve olası alternatif çözümler aramayı umursamıyorsunuz.

Lisp yaklaşımı damıtılmış aşağıdan yukarıya doğrudur. Sadece aşağıdan yukarıya doğru değil, aynı zamanda tuğlaları da ihtiyacınız olan şekilde şekillendirebilirsiniz. Hiçbir şey sabit değil, özgürlük tam. Elbette özgürlük sorumluluk alır ve bu gücü kötüye kullanarak korkunç şeyler yapabilirsiniz.

Ancak korkunç kod herhangi bir dilde yazılabilir. Zihin için kafes şeklinde olan dillerde bile, bu dillerle maymunların bile iyi programlar hazırlayıp çalışmaya başlayabilecekleri umuduyla tasarlandı (o kadar çok konuda yanlış düşünen bile bir fikir).

Örnek, bir web sunucusu hakkında. Şimdi 2012'de bu iyi tanımlanmış bir sorundur, izlenecek özelliklere sahipsiniz. Bir web sunucusu sadece bir uygulama problemidir. Özellikle, orada bulunan diğer gajilyonlarca web sunucusu ile büyük ölçüde özdeş bir web sunucusu yazmayı hedefliyorsanız, bazı minutialar dışında hiçbir şey net değildir. RSA hakkındaki yorumunuz bile hala resmi spesifikasyonlarla açıkça tanımlanmış bir problemden bahsediyor.

İyi tanımlanmış bir problemle, biçimsel spesifikasyonlarla ve zaten bilinen çözümlerle kodlama sadece noktalara bağlanır. Yukarıdan aşağıya bunun için uygun. Bu proje yöneticisi cennetidir.

Bununla birlikte, çoğu durumda, noktaları birleştirmek için kullanıldığı kanıtlanmış bir yaklaşım yoktur. Aslında çok sık noktaların ne olduğunu söylemek bile zor.

Örneğin, kesilecek parçaları, teorik olarak tekrarlayan logoya tam olarak uymayan bir basılı malzemeye hizalamak için otomatik bir kesme makinesinden talimat almanız istendiğini varsayalım. Makinenin çektiği malzemenin parçalarını ve resimlerini alırsınız.

Hizalama kuralı nedir? Sen karar ver. Bir kalıp nedir, nasıl temsil edilir? Sen karar ver. Parçaları hizalamak nasıl? Sen karar ver. Parçalar "bükülebilir" mi? Bazıları değil, bazıları evet, fakat elbette fazla değil. Malzeme bir parçayı kabul edilebilir bir şekilde kesemeyecek kadar deforme olmuşsa ne yapmalı? Sen karar ver. Bütün malzeme ruloları aynı mı? Tabii ki değil, ama kullanıcının her rulo için hizalama kurallarını uyarlamasına izin veremezsiniz ... bu pratik olmaz. Hangi resimler kameraları görüyor? Materyal, her ne demek olursa olsun ... renk olabilir, sadece ışık refleksinin deseni belirginleştirdiği yerde siyah üzerine siyah olabilir. Bir kalıbı tanımak ne demektir ? Sen karar ver.

Şimdi bu problem için bir çözümün genel yapısını tasarlamaya çalışın ve para ve zaman içinde bir fiyat teklifi verin. Bahse girerim ki sistem mimariniz bile (evet, mimarlık) yanlış olacak. Maliyet ve zaman tahmini rastgele sayılar olacaktır.

Uyguladık ve şimdi çalışan bir sistem, ancak sistemin şekli hakkındaki fikrimizi birçok kez değiştirdik. Artık menülerden bile erişilemeyen tüm alt sistemleri ekledik. Protokollerde master / slave rollerini bir kereden fazla değiştirdik. Muhtemelen şimdi daha iyi bir şekilde yeniden inşa etmeye çalışmak için yeterli bilgiye sahibiz.

Elbette diğer şirketler de aynı sorunu çözdü ... ama bu şirketlerden birinde değilseniz büyük olasılıkla yukarıdan aşağıya ayrıntılı projeniz bir şaka olacaktır. Yukarıdan aşağıya doğru tasarlayabiliriz. Bunu yapamazsınız çünkü daha önce hiç yapmadınız.

Muhtemelen aynı sorunu da çözebilirsiniz. Ancak aşağıdan yukarıya çalışmak. Bildiklerinizden başlayarak, bilmediğiniz şeyleri öğrenme ve ekleme.

Yeni karmaşık yazılım sistemleri tasarlanmamıştır, yetiştirilir. Her şimdi ve sonra birisi sıfırdan başlayarak yeni ve karmaşık bir şekilde tanımlanmamış büyük bir yazılım sistemi tasarlamaya başlar (büyük bir karmaşık yazılım projesiyle sadece üç olasılık olduğunu unutmayın: a) şartname bulanık, b] şartname yanlış veya c] hem ... hem de çoğu zaman [c] durum böyledir).

Bunlar, yalnızca powerpoint slaytlarına ve UML diyagramlarına atılan binlerce ve binlerce saatlik tipik büyük şirket projeleridir. Utanç verici miktarda kaynak yaktıktan sonra tamamen başarısız olurlar ... ya da çok istisnai bir durumda, nihayetinde ilk özelliklerin sadece küçük bir kısmını uygulayan overpriced bir yazılım sunarlar. Ve bu yazılım kaçınılmaz olarak kullanıcılar tarafından çok nefret ediliyor ... satın alacağınız türden bir yazılım değil, kullandığınız türden bir yazılım.

Bu sadece kodlamayı düşünmeniz gerektiğini düşündüğüm anlamına mı geliyor? Tabii ki değil. Fakat bence yapı alttan başlamalı (tuğlalar, beton kodlar) ve yukarı çıkmalı ... ve detaylara odaklanmanız ve dikkatiniz, bir anlamda sahip olduğunuzdan uzaklaştıkça “solmalı” olmalıdır. Yukarıdan aşağıya, çoğu zaman tüm sisteme aynı seviyede ayrıntıyı bir kerede koymanız gerekiyormuşçasına sunulur: her şeyi açıklığa kavuşana kadar her düğümü ayırmaya devam edin ... gerçeklik modüllerinde, alt sistemler alt yordamlardan "büyütülür". Belirli bir problemde daha önce bir deneyiminiz yoksa, bir alt sistem, modül veya kütüphanenin yukarıdan aşağıya tasarımınız korkunç olacaktır. Hangi işlevleri yerine koyacağınızı öğrendikten sonra iyi bir kütüphane tasarlayabilirsiniz.

Lisp fikirlerinin çoğu daha popüler hale geliyor (birinci sınıf fonksiyonlar, kapanmalar, varsayılan olarak dinamik yazma, çöp toplama, metaprogramlama, etkileşimli gelişim) ancak Lisp hala kodları şekillendirmenin ne kadar kolay olduğu konusunda bugün hala (bildiğim diller arasında) ihtiyacın olan şey için.

Örneğin, anahtar sözcük parametreleri zaten var, ancak mevcut değilse, eklenebilirler. Denemekte olduğum bir oyuncak Lisp derleyicisi için (derleme zamanında anahtar kelime doğrulaması dahil) yaptım ve çok fazla kod almıyor.

Bunun yerine, C ++ ile elde edebileceğiniz en fazla şey, anahtar kelime parametrelerinin bu kadar kullanışlı olmadığını ya da inanılmaz derecede karmaşık, kırılmış, yarı destekli bir şablon uygulamasının gerçekten de yararlı olmadığını söyleyen bir grup C ++ uzmanıdır. C ++ sınıfları birinci sınıf nesneler midir? Hayır ve bu konuda yapabileceğiniz hiçbir şey yok. Çalışma zamanında veya derleme zamanında inceleme yapabilir misiniz? Hayır ve bu konuda yapabileceğiniz hiçbir şey yok.

Lisp'in bu dil esnekliği, aşağıdan yukarıya bina için harika kılan şeydir. Sadece alt yordamları değil, aynı zamanda dilin sözdizimini ve anlamını da oluşturabilirsiniz. Ve bir bakıma Lisp'in kendisi aşağıdan yukarıya doğru.


Evet, demek istediğim yerel bir tepeydi. Gereksinimi hassaslaştırmaya devam ediyor ve yinelemeler yoluyla geliştiriyorsunuz. Yukarıdan aşağıya nokta, kod yapısını olabildiğince doğru almak istiyoruz. Sürekli refactoring. Örneğin, ilk önce bir işleve bir dize iletmek istiyorsunuz, ancak daha sonra değişiklikleri karşılamak için tüm bir sınıfa ihtiyacınız vardır ve işlev zaten her yerde kullanılıyorsa yeniden düzenleme işlemi zaman alıcıdır.
Amumu

Açıkça bilinen bir şekilde açıkça bilinen bir şeyi yeniden oluşturmak için yukarıdan aşağıya ok tamamdır. Web tarayıcınız buna bir örnektir. Sizi beklemek ve resmen belirtmek için zorlayan C ++ gibi bir dil bile (korkunç bir sözdizimi kullanarak), programınızın tüm değişkenlerinde tutulan değerlerin tüm türlerini hala uygun bir seçenektir.
6502

Örneğimin açıkça bilinen bir yöntem olduğunu sanmıyorum, çünkü bunun veri iletişiminin temel bilgisine sahip biri tarafından yapıldığını ve C ++ kodunun etki alanı bilgisinden çok temel tasarımın sonucudur (bu durumda ağ oluşturma) olduğunu düşünüyorum. . Bu bir evrim tasarımı örneğidir. Bir sonraki yinelemede, geliştirici alan bilgisi hakkında daha fazla şey öğrenir, bu yüzden tasarımını gelişen bilgiye uyacak şekilde genişletir (örneğin, web sunucusunun her katmanında ek güvenlik özellikleri gibi). Daha sonra uygulamayı yeni tasarıma göre düzenler.
Amumu

Buradaki nokta, etki alanından bağımsız bir dilden türetilen asıl çözümün (doğal dil, matematik dili ... gibi etki alanına bağlıdır) olmasıdır. Kodlama eylemi üretilen çözümden koda kadar sadece ayrıntılı bir haritalamadır.
Amumu

1
Selam Bay. Bir yıl sonra, daha fazla şey öğrendiğim gibi, söylediklerinizin daha gerçek olduğunu görmeye başladım. Başka bir konu daha yaptım: programmers.stackexchange.com/questions/179000/… . Zamanın varsa, umarım düşüncemi tekrar açıklarsın: D.
Amumu

6

Bu cevap Lisp için de geçerli olacak nasıl emin değilim, ama sadece okumayı bitirdikten Çevik İlkeleri, Desenleri ve Uygulamalarını ve yazar, amca Bob , şiddetle savunan yukarıdan aşağıya C # (C ++ için de geçerlidir) için yaklaşımla hangi ile ben tam anlaşmak.

Bununla birlikte, yukarıdan aşağıya yaklaşımın, ilk etkileşimde yalnızca belgeler ve genel tasarım sunacağınız sonucuna vardığı sonucuna yol açan diğer cevapların aksine, kitabın başka bir yönteme işaret ettiği görülüyor: TDD evrimsel tasarımla birleşti.

Buradaki fikir, en baştan başlayıp en yüksek soyutlama seviyelerinizi (veya yerel en yüksek) tanımlamanızdır ve tanımlandıkları anda yararlı çalışmalar yapmaları için # 1 özelliğinin hemen çalışması sağlanır. Ardından, daha fazla özellik ekledikçe kodunuzu yeniden değerlendiriyor ve her zaman SOLID ilkelerinin farkında kalırken tasarımı gerektiği gibi geliştiriyorsunuz.. Bu şekilde çok fazla soyutlama katmanı ile bitmezsiniz ve genel mimariye uymayan düşük seviye tasarımlarla bitmezsiniz. Bunun ne anlama geldiğinden emin değilseniz, yukarıda bahsettiğim kitap, geliştiricilerin kavramları aldıkları ve UML diyagramları ve düşük seviye sınıfları ile başladıkları, kodlama gerçekten başladığında sadece bu sınıfların yarısına ihtiyaç duymadığını anlamak için bir bölüm içeren bir bölüme sahiptir. Bu yaklaşımın özünde, projede daha üst düzey detaylar tanımlandığı için düşük seviyeli kod doğal olarak aşağı itilir.

Ve son olarak, SOLID uygularsanız, tanımlanmış üst düzey soyutlamaların olduğu bir durumla karşılaşmamalısınız ve daha sonra ayrıntılara girmelisiniz ve aniden OOD veya soyutlamalar olmadığını anlayın. Bu gerçekten yukarıdan aşağıya tasarımın değil, tembel mühendisliğin hatası.

XP ve evrimsel tasarım hakkında daha fazla bilgi edinmek istiyorsanız, işte bir başka büyük yazar: Martin Fowler'tan "Okuduğum Tasarım Öldü mü?"


Mükemmel. Bahsettiğim budur. Ayrıca SOLID ilkesi hakkında bilmek güzel ve Agile yukarıdan aşağıya yaklaşımı destekliyor (TDD ve XP ile insanların en kısa zamanda kodlamaya atladıklarını ve dokümantasyondan kaçınmalarını düşündüm).
Amumu

@Amumu: Fowler tarafından yazılmış başka bir makaleye bağlantı ekledim. Herhangi bir tasarım / dokümantasyon içermeyen kovboy kodlaması arasındaki farkı ve XP / Agile'nin aslında ne teşvik ettiğini okuyabilirsiniz. Kişisel olarak, dökümantasyonun değerli olduğuna kesinlikle inanıyorum ve ekibimi tasarım dokümanlarımızı sürdürmesi için aktif bir şekilde teşvik ediyorum, görüşlerimi yavaş yavaş değiştiriyorum. Şimdi "tasarım görevlerimiz" beyaz tahta / peçete tipinde şeylerdir, ancak gerçek dokümanlar ancak hikaye yazıldıktan sonra güncellenir. Ayrıca belgelendirilenleri yeniden değerlendiriyoruz, böylece dokümanlar yalnızca üst düzey / mimari unsurları kapsar
DXM

3

Bana göre, Paul Graham'ın makalesinde yaptığı en önemli sözler şunlardır:

[...] Lisp programcıları [...] aşağıdan yukarıya tasarım denilen bir prensibi izler - soruna uygun dili değiştirir. Lisp'te programınızı dile doğru yazmaz, dili programınıza doğru oluşturur.

Veya, C ++ çevrelerinde bilindiği gibi: Kütüphane Tasarımı Dil Tasarımıdır (Bjarne Stroustrup)

Yukarıdan aşağıya tasarımın ana fikri şudur: önce plan yap, sonra kodla. Beanow yazarken doğrudur , çalıştırılabilir kod işlemin geç geldiğinde sorunlar vardır. Aşağıdan yukarı tasarımda her zaman kodunuz ve test edilebilecek kodunuz vardır.

Ayrıca, kodunuz düz değil. Demek istediğim, daha küçük soyutlama seviyelerine sahip olma eğilimindedir. Yukarıdan aşağıya tasarımda insanlar genellikle keyfi bir düzeye inen ve büyük ölçüde soyutlama yapmayan büyük soyutlamalar yapar. Tasarlanan kod, aşağıdan yukarıya doğru OTOH genellikle daha az düşük seviye kontrol ve veri yapıları içerir çünkü bunlar muhtemelen soyutlanmaları muhtemeldir.


2

İdeal olarak, sadece Lisp değil, herhangi bir dilde bir program yazmak, sizi bir sonraki programınıza ya da mevcut programınıza geliştirmeleri hızlandırabilecek bir dizi jenerik araç yazmanıza olanak tanır.

Uygulamada, bu araçların izini sürmek zor olabilir. Belgeleme fakir ve dağınık ve onları tanıyan insanlar ayrılıyor. Uygulamada, kodu tekrar kullanmak çoğu zaman değmezden daha zordur. Ancak kodun doğru bir şekilde belgelenmesi ve düzenlenmesi ve programcıların yapışması (veya kendi yararlı kodlarını sağlaması) durumunda, kodun yeniden inşa edilmesi yerine depodan alınmasıyla büyük miktarda bir çalışma kurtarılabilir.

Tüm tasarımın üstte olması gerekir, yoksa ne yaptığınızı bilmiyorsunuzdur. Bir kulübe mi yoksa araba mı kuruyorsun? Bunu aşağıdan yukarıya tasarımıyla çözemezsiniz. Ancak, sol ön tekerlek inşa edecekseniz, hem bu proje hem de diğerleri için daha fazla tekerleğe ihtiyaç duyabileceğinizi düşünebilirsiniz. Yeniden kullanılabilir bir tekerlek inşa ederseniz, bir fiyatına dört sahip olacaksınız. (Ve sonraki inşaa ettiğiniz o çekici römork için 18, hepsi ücretsiz.)

Gerçek araçlardan ve gerçek tekerleklerden farklı olarak, tek bir yazılım "tekerlek" geliştirdiyseniz, sonsuz sayıda ürettiğinizi unutmayın.

Daha yukarıdan aşağıya tasarım üzerine: Bu işe başlamak varken, sana eğer işaret almak zorunda hissetmeyin edemez bir tekerlek oluşturmak, bunu out bulmalıyız önce arabanızda çok iş yapmak. Bu yüzden aşağıdan yukarıya, yukarıdan aşağıya çalışmaya paralel olarak çalışmanız gerekir. Ayrıca, bilerek olabilir bir tekerlek inşa traktör-römork gibi önce düşündüm olmazdı projeleri bir sürü önerebiliriz. Yukarıdan aşağıya yaklaşımın baskın olması gerektiğini düşünüyorum ama çok hafif bir dokunuşla.

Bu yüzden, Paul Graham'ı yeniden ifade etmeye devam etmek için, ideal olarak bir program yazarken hem orijinal programda hem de diğerlerinde çok fazla zaman kazandırabilecek çok sayıda yeniden kullanılabilir parça ile karşılaşırsınız. Kendimi Paul Graham'dan biraz uzaklaştırmak için, bu herhangi bir dilde çalışır (bazıları süreci diğerlerinden daha fazla teşvik eder).

Bu neredeyse büyülü sürecin düşmanı, çok kısa vadeli bakış açıları olan programcılar. Bu, kişilik kusurlarından kaynaklanabilir, ancak daha yaygın olarak, hem içinde hem de çalışan şirketler arasında işleri ve sorumlulukları çok hızlı bir şekilde değiştirmekten kaynaklanabilir.


Vay ben 16 Şubat'tan cevap aldım ve gelen kutusu hiçbir şey göstermedi. Sizinle aynı fikirdeyim, her zaman bir planın, hatta çok hafif bir planın olması ve ardından biraz inşa edilmesi ve ardından planın iyileştirilmesi gerekir. Tamamen mantıklı. Ancak, birçok geliştiricinin kod yazarken neden her şeyi başlarında planlamayı sevdiklerini anlayamadım. Oldukça zaman kazanılabilir ve uygulama sürecinde kod mimarisini sürekli yeniden yansıtmak yerine asıl sorun üzerinde daha fazla çalışmaya odaklanabilirler.
Amumu

@Amumu Yazarken planlamanın bir nedeni: Bazı programcılar klavyede ne yaptıkları hakkında çok şey biliyorlar ve fare kodlama darboğazları değil planlama süreci. (Yeniden kullanılabilir kod, tekrar zor kısmı düşünmelerini sağlayacak yeni ve yaratıcı çalışmalar
yapmalarını sağlar

@Amumu Yazarken planlamanın başka bir nedeni: Bazı dil / programcı / problem kombinasyonları ile dil, problemi düşünmenin en iyi yoludur. Dil, düşüncelerinizi "kağıt" üzerine koymanın en kolay yoludur. Burada ve orada sadece Lisp hakkında küçük parçalar okudum, ancak bundan özellikle bunun için iyi olduğundan şüpheleniyorum. (Bazı diller ilk önce sorunu çözmek için bir makineye sahip olmak yerine bir sorunu ifade etmenin bir yolu olarak oluşturulmuştur.) Kodunuzu düşünceleriniz kadar yeniden düzenlemek kolaysa kod da olabilir. Ancak programcının, dilin ve problemin bunun çalışması için iyi bir şekilde harmanlanması gerekir.
RalphChapin

Güvenilir. Planlama fikri, alan bilgisi ile alan tanımları arasındaki ilişki tanımlarını gerçek programlama sürecine ayırmaktır. Bir sınıfın, diğer sınıflarla düzinelerce kullanıldığını, diğer sınıflarla iletişim kurmak için arayüz oluşturmayı iyi bir plan yapmadan düşününce, kolayca entegrasyon ve yeniden cehenneme girebiliriz. Bu durumda, kodu yazmak ve yeniden yapılandırmak için boşa harcanan zaman, kağıt üzerinde tanımlamak için harcanan zamanı büyük ölçüde aşmaktadır.
Amumu

Bir örnek verelim: Bir istemci / sunucu uygulaması yazdığımızı varsayalım. Protokolü değiş tokuş mesajlarını, mesajın hafızada nasıl düzenlendiğini tanımlayarak tanımlamamız gereken ilk şey (ör. Başlık 16 bayt, id 4 bayt ....). Diyagram, modelleme / planlama ile aynı değildir: abstratt.com/blog/2009/05/03/on-code-being-model . Model oluşturmak için UML veya şemayı kullanmamıza gerek yok, çünkü UML sadece OOP'a odaklanıyor ve UML sınıf şemasına yazarak harcanan süre asıl kodu yazmadan daha az değil.
Amumu

1

İteratif geliştirme ile birlikte yukarıdan aşağıya yaklaşımın nesi yanlış?

Yinelemeli geliştirme ile yukarıdan aşağıya bir yaklaşım kullanmak, ilk yinelemelerde herhangi bir çalışma kodu sağlamaz. Tasarım belgeleri sunar ve müşterinin geri bildirimde bulunmak için zor anlar yaşayacağı bir ortam sunar. "Evet sanırım (bu benim için çok soyut)" gibi yanıtlar, müşterinin istediği sistemin özelliklerini daha da belirtmenizde size yardımcı olmayacaktır.

Bunun yerine, yalnızca istenenlere genel bir genel bakış oluşturursunuz. (Gereksinimler) bitmiş bir ürünü neyin tanımladığı ve neyin uygulanması öncelikli olduğu için genel bir kılavuz olarak kullanmak. Bu noktadan sonra, müşterinin aklındaki şeyin bu olup olmadığını görmek için gerçekte oynayabileceği her yineleme için çalışan ürünler yaratırsınız. Aksi halde, müşterinin şu anda istediğinden farklı çalışan bir sistemi tasarlamak için yüzlerce saat harcanmamış olması sorun olmayacak.

Paul Graham inşayı tamamen aşağıdan yukarıya teşvik etti mi? Veya sadece aşağıdan yukarıya doğru programlayın, fakat ihtiyaç analizi / tasarım aşamasını değil mi?

Başka biri için konuşmayacağım. Ayrıca makalesini okumadım. Size verdiğim cevap, eğitimim kadar deneyimlerimden geliyor.

Bu, Lisp'te bir program yazma dönemi boyunca, asıl programın benzer programlarını yazmak için kullanılabilecek genel bir araçla sonuçlandığınız anlamına gelir, değil mi?

Bu yaklaşımı kullanmak, daha soyut yapı taşları ile sonuçlanacağınız anlamına gelir. Basitçe, hemen sunulabilecek bağımsız alt sistemler kurmak zorunda kalacağınız için, yoğun bir şekilde iç içe geçmiş ve hepsinin bir kerede uygulanması gereken yukarıdan aşağıya bir tasarım oluşturamazsınız. Yeniden kullanılabilirliği, sürdürülebilirliği arttırır, ancak hepsinden önemlisi değişime daha esnek yanıt verir.


1
Boldface, gözlerime, zaten blok alıntı yaparken gereksizdir…
mk12
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.