Kodlama sırasında analiz yaparak felci nasıl yenebilirim?

Yeni bir projeye başladığım zaman, çoğu zaman derhal uygulamanın detayları hakkında düşünmeye başlıyorum. “DataBaseHandler'ı nereye koyacağım? Onu nasıl kullanmalıyım? Onu kullanmak isteyen sınıflar, bazı Soyut süper sınıflardan uzanmalı mı?” Bir arayüz kullanmalı mıyım? Sınıfımda hangi seviyede soyutlamayı kullanacağım? istekleri gönderme ve veri ayrıştırma yöntemleri? "

Uzatılabilirliği ve yeniden kullanılabilirliği kodlamak istediğim için uzun süre duruyorum. Ancak nasıl mükemmel şekilde uygulanacağını düşünerek geçmişe geçmenin neredeyse imkansız olduğunu hissediyorum.

Ve sonra, sadece "vidala, sadece hallet!" Demeye çalışırsam, çok hızlı bir şekilde bir tuğla duvara çarptım, çünkü kodum organize değil, soyutlama seviyelerini karıştırdım, vb.

Yeni bir projeye başlamanın yanı sıra iyi ölçeklenecek bir mantıksal / modüler yapı kurarken sahip olduğunuz bazı teknikler / yöntemler nelerdir?

- - EDIT - -

Eh, bu zaten bir cevabı kabul etmesi zor, ancak biraz daha fazla geri bildirim almak isteyen, bazı fikir birliği olup olmadığını görmek için sorulan soru türüdür. TDD gerçekten kulağa hoş geliyor ve açıkçası, JUnit, vb. Kullanma konusunda daha fazla hız kazanmaya niyetli oldum. Aynı zamanda, TDD hayranları TDD ile olan ilişkinin meşru bir noktaya değindiğini düşünüyor. Özel hususlar, TDD'nin gerçekten tasarım sorununu ele almadığı görülüyor. Elbette, TDD'nin ne yapmak istediğimi tanımlamamda bana yardımcı olacağına katılıyorum ve daha sonra kademeli olarak nasıl çalışabileceğime katılıyorum, ancak hepsinin birim testinden geçebilecek birçok genel tasarım deseni / yapısı var. Hepsi bu: tek ÜNİTELERİ test ediyor. Sanırım biraz kafam karıştı ... bilmiyorum. Belki ben'

Teşekkürler!

Test-Driven-Development kullanarak öneriyorum , özellikle de tutulma gibi iyi bir IDE ile çalışırken alışmak biraz zaman alıyor ancak avantajları çok iyi.

Temel olarak yaptığınız şey, kodu yazmadan önce testleri kodunuza yazmaktır. Bu nedenle, kodunuza nasıl kullanılacağı açısından bakmaya zorlanırsınız; bu, arabirimlerinizin uyguladığınız daha fazla senaryoyu geliştirdiği anlamına gelir.

Diğer bir özelliği de çok küçük parçalara uygulamanızdır (teknikte ve programlamada ne kadar deneyimli olursanız o kadar büyür), bu nedenle sizi her zaman çok küçük ve iyi tanımlanmış bir soruna odaklanmaya zorlar.

Ayrıca, önce bir test yazıp yalnızca uygulayacağınız için, önünüzde başarısız bir test yapılır. Bu nedenle çoğu programcı gibiyseniz, çılgınca analizlerden uzak durmayacaksınız çünkü şöyle düşüneceksiniz: "Bu testi yapmam gerekiyor".

Kısa bir java örneği:
Bir db'den mesaj okuyan ve yazan bir program geliştirmek istediğimi söyle.

Bu yüzden ilk iyi tanımlanmış eylemle başlıyorum, bir DB'ye ihtiyacım var:

@Test
public void testDB() {
  DB db = DbConnector.getDB(address);
  assertNotNull(db);
}

Tamam, burada DbConnector.getDB sınıfını uygulamam gerektiğini ve böylece bu testin başarısız olmasına kadar DB'yi döndürmesini görüyorum. Ben gidip bunu yapıyorum ...

Yapmak istediğim bir sonraki şeyi eklemediğimde, mesajı DB'den yükleyin:

@Test
public void testDB() {
  DB db = DbConnector.getDB(address);
  assertNotNull(db);
  String message = db.fetchMessage(key);
  assertEquals("hello world", message);
}

Şimdi bir mesaj almak için DB'ye başka bir küçük özellik daha ekledim, gidiyorum ve uyguladım, bir kez bittiğinde şu anda bir özellik kullanmaya devam ediyorum:

@Test
public void testDB() {
  DB db = DbConnector.getDB(address);
  assertNotNull(db);
  String message = db.fetchMessage(key);
  assertEquals("hello world", message);
  message = "foo bar";
  db.storeMessage(message);
  message = db.fetchMessage();
  assertEquals("foo bar", message);
}

Çok basit bir örnek gibi görünebilir, ancak bu daha karmaşık işler için de geçerlidir. İlk başta çok zaman alıcı olduğunu biliyorum ama buna alışınca aslında daha verimli olduğunu görüyorsunuz. Birincisi analizden paraliziden kaçınırsınız ve bir diğeri için genellikle daha az böcek içeren ve daha az yinelemeden geçen çok daha sağlam bir kod alırsınız.

Bu benim başıma geliyor, bu yüzden sürekli refactoring bir zihniyetini kabul etme (ve benimseme) alışkanlığına girdim. İşe yarayabilecek en basit şeyi yapıyorum, sonra temizliyorum, organize ediyorum, ayırıyorum, test ediyorum ve devam ediyorum.

Bu pek bir planlamanın olmadığını söylemek değildir, ancak hurda ya da kafamda karalamalar gibi çok hızlı ve daha sık olur. Sonuç olarak, bazen bu küçük süreç mikro-yinelemelerini adlandırıyorum çünkü her biri 5-20 dakika alıyor ve deneyimlerimden üzerinde çalıştığım şeyi bitirmek 2-3 alıyor (ne yaptığımı bağlı olarak).

Bir not olarak: Çok sayıda insana farklı yazma biçimlerinde (genel olarak raporlar, makaleler ve teknik yazı yazma) ders verdim ve bu aynı şekilde yazar bloğunun üstesinden gelmek için bir şeyler yazmalarını sağladım. “Sadece sayfanızda aklınıza gelen konuyla ilgili her şeyi patlatın. Daha sonra anlamlandıracağız ve hepsini paragraflara ayıracağız ve akışı kontrol edeceğiz. Gerekirse tekrar yazacağız.”

İşe yarayabilecek birkaç şey:

• Çözmeye çalıştığınız temel sorunu belirleyin - yapmak istediğiniz şeyin kalbi nedir? Sadece bunu ve çalışmasını sağlamak için minimum destek kodunu uygulayın. Memnuniyetinize uygun bir şekilde çalıştığında, her adımda merhametsizce yeniden düzenleyerek, yinelemeli bir şekilde oluşturun.
• Diğer programlama paradigmalarının sizin için çalışıp çalışmadığını görün. Tüm özelliklerine rağmen, nesne yönelimli programlama tüm sorunların cevabı değildir ve tüm programcıların beyni bu şekilde çalışmaz. (Saf) bir işlevsel dil seçin; bazı prosedürel kodlar yazmak; donanım seviyesine inin ve bir miktar C, hatta bir süre montajcı yapın; Vücudunuzu sarsabilecek birkaç dil (şu anda C ++ / Java / C # / VB / ... gibi bir şey kullandığınızı varsayarsak): Haskell, ML, Lisp (aralarından seçim yapabileceğiniz çeşitli lehçeler), Erlang, Prolog, Smalltalk, Javascript (Java gibi davranmaya ve onun yerine kapanma doğasını benimsemeye çalışmayı bırakmaya kalkarsanız), C, Pascal, awk ve muhtemelen bir düzine daha. Temel özellik, şu anda kullandıklarınızdan çok farklı olmaları gerektiğidir. Bu büyük bir projede yapmak istediğin bir şey değil.
• Çok farklı bir tasarım yöntemi kullanın. Bakalım, tasarımı farklı bir açıyla alabilir misiniz? Genelde sınıflarınızı düzenleyerek tasarım yapmaya başladığınızı varsayıyorum; Bir değişiklik için veri yapılarıyla başlasanız nasıl olur? Veya herhangi bir işlevsellik tasarlamadan önce kullanıcı arabirimini ilk önce, kelimenin tam anlamıyla giriş formları çizmeye ne dersiniz?

Birçok tasarım kararı için, atılabilir bir prototip kodlayarak bazı mimari veya tasarım seçeneklerini keşfedebileceğiniz kısa, zaman sınırlı bir araştırma çabası olan bir "başak" yapmaya yardımcı olabilir. Örneğin, bazı açık kaynaklı kütüphanelerin kullanımını veya sınıflarınızı ve arayüzlerinizi nasıl organize edeceğinizi keşfedebilirsiniz. Bunların anahtarı kısa kalmaktır, böylece birincisi tatmin edici değilse başka bir yaklaşımı deneyebilirsiniz ve umarım mimari kararları daha iyi almak veya kavramı kanıtlamak için alıştırmada yeterli bilgi edinebilirsiniz. Alıştırmanın kendisi, çok erken bir tarihte "git" e gitmeyi taahhüt etmeden "yazar blokundan" çıkmaya yardımcı olan hemen kodlamayı içerir.

Bundan sonra, Asaf'ın projenin uygulanması ile devam etmesi için bahsettiği TDD veya BDD yaklaşımını kullanmak faydalı olacaktır.

İhtiyacın olmayacak , o yüzden başında çok fazla düşünme.

Amaç ve sorunu tanımlamak, anlamak için daha fazla zaman harca.

"Genişletilebilirlik ve yeniden kullanılabilirlik", iyi yazılmış yazılım programlarının yaşam döngüsünün doğal sonucudur.

Orta büyüklükte bir projeye baktığımızı varsayacağım.
Çizim tahtasına giderek başlardım. Bunu yapmadan önce işlevsel ve işlevsel olmayan gereksinimlerinize hazır olmalısınız. Öncelikle yazılım mimarisiyle karşılaşacaktınız, yani gereksinimlerinize uyacak mimari desenlere
bakacaksınız Mimarisini nasıl görüneceğine karar verdikten sonra, düşük seviyeli tasarıma girmelisiniz, tüm varlıklara, sınıflara ve işlevselliğe bakmalısınız. . Burada tekrar uyan tasarım desenlerini tekrar deneyecek ve tanımlayacaksınız. Süreçte, temel sınıflarınızın ne olduğunu ve ihtiyacınız olan arayüzleri bilirsiniz.
Daha sonra çerçeveyi oluşturabilir ve bunu görmek için bazı hızlı testler yapabilirsiniz. işlevsel olmayan gereksinimlerinizi karşılar
Daha sonra @Asaf'ın önerdiği gibi Test Driven Development ile birlikte giderdim.

Unutmayın, tasarım ve mimaride iyi vakit geçirmesine rağmen, ihtiyaç duyulursa mimariyi her zaman tekrar ziyaret etmeye istekli olun.

Bence bu harika bir soru ve hiçbir şey herkes için işe yaramayacak. Böyle bir felsefenin, alanınızda daha fazla yetkin olmanın doğal bir yan ürünü olduğunu düşünüyorum. Bununla birlikte, bu yardımı yaptığım birkaç şey var, ancak sorunu çözmüyor:

• Bozulmamış projenizi bir kenara bırakın ve titiz bir şekilde çalışın. Bu, kendinize anlattığınız sürüm: a. Kodun güzel olmaması gerekiyordu. Aslında, kendinize söyleyin, büyük yeniden düzenlemeye ve yeniden biçimlendirmeye izin verilmiyor. Tamamen örgütlenmemiş ve kendinizi iyi kodlama bağlarından kurtarınız. b. Sadece çalışması gerekiyor. c. Diğer tüm endişeleri aştığım zaman sorun alanı hakkında ne öğrendim, her zaman şaşırtıcı. Ayrıca çoğu zaman doğru tasarıma daha aydınlık bir şekilde gelmeme yardımcı olan küçük çerezlerle de karşılaşıyorum.

• Sadece bilgisayar olmadan projenin neresinde olduğunuzu iyi bir zaman diliminde ayırın. Gerçekten başarmaya çalıştığınız şeyi kavramsallaştırmaya çalışın ve OO / Design Pattern deliliğini aşan o sihirli zen'i arayın.

Düşüncelerinize somut bir ifade verin: onları yazın / yazın, çizin ya da her neyse. Bu, gerektiğinde düşüncelerinizi tekrar gözden geçirmenize yardımcı olacaktır; çevrelere girmenizi engelleyecektir; daha net düşünmenize yardımcı olur.

Ne zaman kendimi hiçbir yere gitmediğini ve her yerde bir şey hakkında düşündüğümde, onları yazıyorum ve net bir şekilde düşünmeme yardımcı oluyor.

Genelde sıfırdan başlıyorum, mümkün olan en basit prototipi yaratıyorum ve bir şeyler çalıştırıyorum. Mutlu yol test durumlarını tersine çevirmek için prototipi, arayüzleri yönlendirmek için test durumlarını test etmek ve daha sonra test kapsamı oluşturmak için ön / son sözleşmeleri düşünün.

Sorun tam olarak anlaşılıncaya kadar soyutlama, optimizasyon veya doğrulama konusunda endişelenmeyin.