Daha iyi verimlilik elde etmek için aptal olmak?

"İyi tasarım", "tasarım desenleri" vb. Hakkında farklı kitaplar okumak için çok zaman harcadım. SOLID yaklaşımının büyük bir hayranıyım ve her zaman basit bir kod parçası yazmam gerekiyor. gelecek. Bu nedenle, yeni bir özellik veya bir hata düzeltmesi uygulamak, bunun gibi sadece üç satır kod eklemenizi gerektiriyorsa:

if(xxx) {
    doSomething();
}

Bu şekilde yapacağım anlamına gelmez. Bu kod parçasının en yakın gelecekte daha büyük bir hale geleceğini düşünüyorsanız, soyutlamalar eklemeyi, bu işlevi başka bir yere taşımayı ve bunun gibi şeyleri düşüneceğim. Takip ettiğim hedef ortalama karmaşıklığı değişikliklerden önceki ile aynı tutmak .

Kod açısından, oldukça iyi bir fikir olduğuna inanıyorum - kodum asla yeterince uzun değildir ve sınıflar, yöntemler ve sınıflar ve nesneler arasındaki ilişkiler gibi farklı varlıkların anlamlarını anlamak oldukça kolaydır.

Sorun şu ki, çok zaman alıyor ve bu özelliği "olduğu gibi" uygularsam daha iyi olacağını düşünüyorum. Sadece "üç satır kod" ve "yeni arayüz + bu arayüzü uygulamak için iki sınıf" hakkında.

Ürün açısından ( sonuçtan söz ederken ) yaptığım şeyler anlamsız. Bir sonraki sürümde çalışacak olursak, iyi kodlara sahip olmanın gerçekten harika olduğunu biliyorum. Ancak diğer tarafta, kodunuzu "iyi" yapmak için harcadığınız zaman birkaç yararlı özellik uygulamak için harcanmış olabilir.

Sonuçlarıma karşı genellikle çok tatminsiz hissediyorum - sadece A'yı yapabilen iyi kod, A, B, C ve D'yi yapabilen kötü koddan daha kötü.

Bu yaklaşımın bir yazılım projesi için olumlu bir net kazanca neden olması muhtemel midir, yoksa zaman kaybı mıdır?

A'yı yapabilen iyi kod, A, B, C, D yapabilen kötü koddan daha kötüdür.

Bu bana spekülatif bir genellik gibi kokuyor . Müşterilerinizin B, C ve D özelliklerine ihtiyaç duyacaklarını bilmeden (ya da en azından makul bir şekilde emin olmak istiyorsanız), tasarımınızı gereksiz yere aşırı karmaşıklaştırıyorsunuz. Uzun vadede daha karmaşık kodları anlamak ve sürdürmek daha zordur. Ekstra karmaşıklık sadece faydalı ekstra özellikler ile haklı çıkarıldı . Fakat biz geleceği tahmin etmekte genelde çok kötüyüz. Gelecekte ihtiyaç duyulabileceğini düşündüğümüz özelliklerin çoğu, asla gerçek hayatta istenmeyecek .

Yani:

Yalnızca A'yı yapabilen iyi kod (ancak bunu basit ve temiz bir şey yapıyor), A, B, C, D (bazıları gelecekte gerekli olabilir ) olan kötü koddan daha iyidir .

Fıkra zaman:

Bu şekilde aşırı mühendisliğe yönelen iki geliştiricim benim için çalıştı.

Bunlardan biri için, bu temel olarak verimliliğini, özellikle yeni bir projeye başlarken durma noktasına getiriyor. En önemlisi, eğer proje, doğası gereği, oldukça basitse. Sonuçta şu anda çalışan bir yazılım parçası ihtiyacımız olan şey. O kadar kötüleşti ki gitmesine izin vermek zorunda kaldım.

Aşırı mühendisliğe yatkın olan diğer geliştirici, son derece üretken olmak için yarattı. Gibi, tüm yabancı yasalara rağmen, hala çoğundan daha hızlı teslim edildi. Bununla birlikte, şimdi harekete geçtiği için, kendimi genellikle (tamamen gereksiz) soyutlama katmanlarını değiştirmeniz gerektiğinden, işlevsellik eklemek için gereken ekstra iş miktarında rahatsızlık duyuyorum.

Dolayısıyla ahlaki, fazla mühendislik faydalı şeyler yapmak için daha iyi harcanabilecek fazladan zaman tüketir. Ve sadece kendi zamanınızı değil, aynı zamanda kodunuzla çalışmak zorunda olanları da.

Öyleyse yapma.

Kodunuzun mümkün olduğunca basit olmasını istiyorsunuz (ve daha basit değil). 'Maybes'i kullanmak hiçbir şeyi basitleştirmez, yanlış olduğunu düşünüyorsanız kodu göstermek için gerçek bir kazanç olmadan kodu daha karmaşık hale getireceksiniz.

KATI ve KISS / YAGNI ilkeleri kutuplara yakındır. Birisi, eğer doSomething (), yaptığı işi yapan sınıfın işin ayrılmaz bir parçası olarak haklı çıkarılamazsa, gevşek bir şekilde bağlanmış ve enjekte edilmiş farklı bir sınıfta olması gerektiğini söyleyecektir. Diğeri size, eğer bir şey kullanılan bir yerse, birşeyin kullanıldığını, hatta onu bir yönteme çıkarmanın, fazladan kalmış olabileceğini söyleyecektir.

Bu, iyi programcıların altındaki ağırlığına değmesini sağlayan şeydir. “Uygun” yapı, mevcut kod temeli, programın gelecekteki yolu ve programın arkasındaki işin ihtiyaçları hakkında bilgi gerektiren durum bazında bir temeldir.

Bu basit üç aşamalı metodolojiyi takip etmeyi seviyorum.

• İlk seferde çalışsın.
• İkinci seferde temizleyin.
• Üçüncü seferde, SOLID yapın.

Temel olarak, KISS'i SOLID ile nasıl harmanlayacağınız budur. İlk önce bir kod satırı yazdığınızda, tüm bildiğiniz bir kereye mahsus olacak; Sadece çalışması gerekiyor ve kimse umursamıyor, bu yüzden süslü olmayın. İmlecinizi bu kod satırına ikinci kez koyduğunuzda, orijinal hipotezinizi ispatladınız; Bu kodu tekrar gözden geçirirken, muhtemelen onu uzatacak veya başka bir yerden kodlayabileceksiniz. Şimdi, biraz temizlemelisin; Yaygın olarak kullanılan haberleşmeler için yöntemler çıkartın, kopyala / yapıştır kodunu azaltın veya ortadan kaldırın, birkaç yorum ekleyin, vb. Şimdi bunu programınızın temel bir parçası olarak görmeli ve uygun olan yerlerde SOLID kurallarını uygulamalısınız.

Örnek: Konsola basit bir metin satırı yazmanız gerekir. Bu ilk olduğunda, Console.WriteLine () gayet iyi. Ardından, yeni gereksinimlerin ardından aynı satırı bir çıktı günlüğüne yazmayı da belirleyerek bu koda dönersiniz. Bu basit örnekte, çok fazla tekrarlayan "kopyala / yapıştır" kodu olmayabilir (veya belki de vardır), ancak yine de bazı temel temizleme işlemleri yapabilir, belki de IO işlemlerini daha derin bir iş mantığına dahil etmek için bir veya iki yöntem çıkarabilirsiniz . Ardından, istemci bir izleme sunucusu için adlandırılmış bir boruya aynı metin çıktısını istediğinde geri dönersiniz. Şimdi, bu çıkış rutini bir hayli önemli; aynı metni üç şekilde yayınlıyorsunuz. Bu, Kompozit modelden faydalanacak bir algoritmanın ders kitabı örneğidir; Write () yöntemiyle basit bir IWriter arayüzü geliştirmek, ConsoleWriter, FileWriter ve NamedPipeWriter sınıfları oluşturmak için bir arayüz ve "MultiWriter" bileşik sınıfı oluşturmak için bir kez daha uygulayın, ardından sınıfınıza bir IWriter bağımlılığı gösterin, MultiWriter üçlü yazarla birleşik olarak ayarlayın ve takın. Şimdi, oldukça sağlam. bu noktadan itibaren, ne zaman gereksinimler çıktının yeni bir yere gitmesi gerektiğine karar verdiğinde, yeni bir IWriter oluşturup MultiWriter'a bağlarsınız, mevcut herhangi bir çalışma koduna dokunmanıza gerek kalmaz.

A'yı yapabilen iyi kod, A, B, C, D yapabilen kötü koddan daha kötüdür.

1) Sadece yapılması gerekenleri yapan bir kodun olması.

Bu kod parçasının en yakın gelecekte daha büyük bir hale geleceğini düşünüyorsanız, soyutlamalar eklemeyi, bu işlevi başka bir yere taşımayı ve bunun gibi şeyleri düşüneceğim.

2) Kodunuzu A, B, C ve D olarak planlıyorsanız, müşteri sizden E'yi isteyecektir.

Kodunuz yapılması gerekenleri yapmalı, gelecekteki uygulamalar hakkında şimdi düşünmemelisiniz, çünkü kodunuzu sürekli olarak değiştirmeyi asla sonlandırmayacaksınız ve daha önemlisi kodunuzu aşırı tasarlayacaksınız. Elbette, proje mimarisinin bir parçası olarak planlamadıysanız, mevcut özellikleri nedeniyle, ihtiyaç duyduğunu hissettiğiniz andan itibaren kodunuzu yeniden düzenlemelisiniz.

Size iyi bir kitap okumanızı öneririm: Pragmatik Programcı . Zihninizi açar ve ne yapmanız ve ne yapmamanız gerektiğini size öğretir.

Ayrıca Kod Tamamlama , her geliştiricinin (yalnızca programcının değil) okuması gereken yararlı bilgilerle dolu harika bir kaynaktır.

çok zaman basit bir kod yazmam gerekiyor, geleceği düşünüyorum

Belki de burada sorun var.

Erken aşamalarda, nihai ürün ne olacağı hakkında hiçbir fikriniz yok. Ya da varsa, bu yanlış. Kesinlikle. Birkaç gün önce Programcılara sorulan 14 yaşında bir çocuk gibi. Gelecekteki kariyeri için web uygulamaları arasında seçim yapması gerekiyorsa ve başka ne olduğunu hatırlamıyorum: birkaç yıl içinde bu durumun oldukça açık olduğu belli. Değişmeyi sever, diğer alanlarla vb. ilgilenir.

Üç satır kod yazmak için yeni bir arayüz ve iki sınıf oluşturursanız, aşırı mühendislik yapıyorsunuz demektir. Bakımı kolay ve okunması zor bir kod elde edersiniz , çünkü her faydalı kod satırı için, ihtiyacınız olmayan iki kod satırı vardır. XML belgelerini, birim testlerini vb. Saymamak.

Bir düşünün: Bir özelliğin kodunuzda nasıl uygulandığını bilmek istersem, yirmi kod satırını okumak benim için daha kolay olur mu yoksa düzinelerce yarı boş sınıf açmak zorunda kalmanız daha hızlı ve daha kolay olurdu. Hangisinin hangisini kullandığını, nasıl ilişkilendiğini vb.

Unutmayın: daha büyük kod temeli daha fazla bakım demektir. Bunu önleyebildiğiniz zaman daha fazla kod yazmayın.

Yaklaşımınız diğer taraflarda da zararlıdır:

• Bir özelliği kaldırmanız gerekirse, onlarca sınıf arasındaki bağımlılıkları anlamak için zamanınızı harcamak yerine, belirli bir yirmi satır yönteminin nerede kullanıldığını bulmak kolay değil mi?

• Hata ayıklama yaparken, küçük bir yığın izine sahip olmak daha kolay değil mi, yoksa neyin ne dendiğini anlamak için düzinelerce satır okumayı mı tercih edersiniz?

Sonuç olarak, erken optimizasyona benzer görünüyor . Sorunu ilk etapta sorun olup olmadığından ve nerede olduğundan emin olmadan bile çözmeye çalışıyorsunuz. Ürününüzün 1. sürümünde çalışırken, şu anda uygulamanız gereken özellikleri uygulayın; 14 yılda iki yılda uygulayacağınız bir şey düşünmeyin.

Asla kullanılmayacak (muhtemelen) pek çok kod yazmak, P45 ile yayınlanmanın çok iyi bir yoludur . Bir kristal topunuz yok ve geliştirme işleminin bu fonksiyonlar için zaman harcayacağı son yönü hakkında hiçbir fikriniz yok, sadece geri dönüşü olmaz.

Gelecekte koddan neye ihtiyaç duyulabileceğini tahmin etmeye çalışmak çoğu zaman gereksiz mühendislik gerektirmez (şu anda sallamaya çalıştığım bir alışkanlık). Sadece üç satırı yap derim. İhtiyaç ortaya çıktığında (daha önce değil), refactor. Bu şekilde kodunuz her zaman fazla karmaşık olmadan olmadan ihtiyaç duyduğu şeyi yapar ve yeniden yapılanma yoluyla doğal olarak iyi bir yapı geliştirir.

Sıklıkla kodlamanın Gücün aydınlık tarafı / karanlık tarafı gibi olduğunu söylerim - "hafif" taraf daha fazla çaba gerektirir ancak daha fazla sonuç verir. "Karanlık" taraf hızlı ve kolaydır ve derhal daha fazla fayda sağlar ancak yolun aşağısına yol açar. Karanlık yolda başladığınızda, sonsuza dek kaderinize hükmedecektir.

Buna her zaman rastladım, sahip olduğum her işte, kaçamayacağım bir lanet gibi. Şirket kültürü her zaman karanlık tarafın yoludur ve yeni özellikleri ortaya çıkarmak için hızlıca kesilen hackler / düzeltmeler vardır ve yeniden yapılanma ve kod yazma zevkim ve çığlıklarım doğru şekilde sağır kulağıma düşer, bazı şeyleri değiştirmeye çalışmak "(hiç şaka yapmadım, çok az zaman geçirdim, çünkü tasarım kalıplarını tanıtmak ve hızlı bilgisayar korsanlarından uzaklaşmak istiyordum).

Üzücü gerçek şu ki, aptal / karanlık taraf, basmak zorunda olduğunuz yoldur, sadece hafifçe basmak için emin olmanız gerekir. Yazılım yazmanın doğru yolunu anlayan , yani SOLID'i takip eden, tasarım kalıplarını kullanan, SoC'ye uyan vb. Programcıların , ifbir hatayı düzeltmek için bir açıklama yazacak olan ip uçsuz bilgisayar korsanlarından çok daha az yaygın olduklarını yavaşça ve üzülerek anlıyorum. daha fazla hata ortaya çıktığında, "Belki de bunu yapmanın daha iyi bir yolu var" ve kodun uygun şekilde genişletilebilir olması için yeniden düşünmek yerine, sadece bu ifadeyi ekleyin.

Ne olabileceğinin (gelecek) farkında olmak ASLA kötü değildir. Bir şeyi yapmanın daha iyi bir yolu olabileceğini düşünmek, sizi işinizde iyi yapan şeyin bir parçasıdır. Zor olan kısım, harcanan zamanın olup olmadığının belirlenmesidir: getiri oranı haklı. Hepimiz, insanların hemen kanamayı durdurmak için (ve / veya bağırmayı) "eğer kolay" yaptıkları ve kafa karıştırıcı kodlar aldığınız durumlar gördük. Birçoğumuz, orijinal kodlayıcı devam ettikten sonra, aynı zamanda kafa karıştırıcı kod üreten bir gizem olan aşırı soyutlamayı da deneyimledik.

Durumunuza bakar ve şu soruları sorardım:

1. Bu kod görevi önemli mi ve tekrar kodlarsam daha kararlı mı olacak? Ameliyatta, bu yeniden canlandırıcı hayat kurtarıcı mı, yoksa sadece seçmeli ve kozmetik mi?

2. 6 ay içinde değiştireceğimiz yeniden düzenleme kodunu mu düşünüyorsunuz?

3. Yeniden düzenlemeyi yapmak için harcayacağım kadar gelecekteki geliştiriciler için tasarım ve akıl yürütmemi belgelemek için çok zaman harcayacağım mı?

4. Gelecekteki özellikler eklemek için zarif tasarımımla ilgili olarak, bu kod kullanıcıların her hafta değişiklik talep ettiği kodunda mı, yoksa bu yıl ilk kez dokunuşumda mı?

YAGNI ve KISS'in günü kazandığı zamanlar var, ancak temel bir değişikliğin sizi aşağı doğru sarmaldan başbaşa geçirmesine götüreceği günler var. Sadece ne istediğinizi değil, işinizi sürdürmek için başkalarının ne yapması gerektiğine ilişkin değerlendirmelerinizde gerçekçi olduğunuz sürece, hangi durumun hangisi olduğunu daha iyi tespit edebileceksiniz. Oh, yaptığını ve nedenini yazmayı unutma. Sizi takip edenleri kurtaracak, aynı zamanda daha sonra geri gelmeniz gerektiğinde kendinizi kurtaracak.

Stroustrup'un ikinci baskısında 'C ++ programlama dili', (Kullanılabilir sayfam yok)

Yerinde kendiliğinden kod eklemeyin.

ve tavsiyeye uyarak iyi gittim. Tabii ki değişimler var ve bir denge bulmak zorundasınız, ancak kısa parçalar büyük bir spagetti karmaşasından daha iyi test edilebilir.

Ben sık sık, bir davadan iki olaya farklılaşma yaparken, n'yi 2 olayı olarak düşünürseniz, hiç düşünmemiş olabileceğiniz birçok yeni olasılık için bir kapı açtığınızı öğrendim.

Ama sonra YAGNI sorusunu sormanız gerekiyor: Buna değer mi? Gerçekten faydalı olacak mı? Tecrübe sahibi olmak, nadiren yanlış olacağınız ve daha başlangıçta yanlış yaptığınız anlamına gelir.

Her şeyi yerinde çözüldüğü için, bir deseni tanımak ve kodunuzun bakımı zor olup olmadığını, çok fazla soyutlama veya bakımı zor olup olmadığını tespit etmek için yeterince kritik olmalısınız.

Çözüm bu değil ya da öyle, ama düşünmek. :)

"sadece A'yı yapabilen iyi kod, A, B, C ve D'yi yapabilen kötü koddan daha kötüdür."

Bu ürün geliştirmede bir anlam ifade edebilir; Ancak BT uzmanlarının çoğu, ürün geliştirme yerine 'projelerde' çalışmaktadır.

'BT projelerinde', eğer iyi bir bileşen programlıyorsanız, projenin ömrü boyunca sorunsuz çalışacaktır - o zamana kadar 5 veya 10 yıldan uzun sürmeyebilir, o zaman iş senaryosunda modası geçmiş ve yeni bir proje / ERP olabilir. ürün değiştirmiş olabilir. Bu 5/10 yıllık yaşam süresi boyunca, kodunuzdaki hatalar olmadığı sürece hiç kimse bunun var olduğunu ve en iyi düşüncelerinizin yararlarının fark edilmediğini fark etmeyecektir! (kendi trompetinizi yüksek sesle oynamanız iyi değilse!)

Pek çoğu 'Windows Ctl + Alt + Del'i programlamak için bir fırsat elde etmiyor ve bu az sayıdaki şans, kodlarının gelecekteki potansiyelini gerçekleştiremiyor!

Yalın ve / veya çevik kalkınma üzerine birçok kitap bu yaklaşımı güçlendirmeye yardımcı olacaktır: şu anda gerekli olanı yapın. Bir çerçeve oluşturduğunuzu biliyorsanız, o zaman soyutlamaları ekleyin. Aksi takdirde, ihtiyacınız olana kadar karmaşıklık eklemeyin . Verimlilikte önemli bir fark yaratabilecek birçok başka kavramı tanıtan Lean Software Development'i öneririm .

İnsanların doğru ve yanlış şeyler yapmaları hakkında konuşmaları komik. Aynı zamanda, programlama işi hala acı verici bir şekilde zordur ve büyük karmaşık sistemler yazmak için iyi bir çözüm sunmaz.

Belki bir gün, programcılar, sonunda karmaşık yazılımların nasıl yazılacağını bulacağız. O zamana kadar, her zaman önce "aptal" prototip uygulamasına başlamanızı ve ardından kolejlerinizin kodunuzu takip edebilmesi için refactoring için yeterli zaman harcamanızı öneririm.

Daha sonra gelen gerçek gereksinimlere hiç uymayan bu kadar genelleştirilmiş tasarımları gördükten sonra, benim için bir kural tasarladım:

Varsayımsal gereklilikler için sadece varsayımsal kod yazınız.

Yani: Daha sonra meydana gelebilecek değişiklikleri düşünmeniz tavsiye edilir. Ancak, sadece bu gereksinimler ortaya çıkarsa kolayca değiştirilebilecek ve düzeltilebilecek kod için bir tasarım seçmek için bu bilgileri kullanın. Hatta kafanızda (varsayımsal kod) bu durumda yazmak isteyeceğiniz bir kod bile yazabilirsiniz, ancak gerçek bir kod yazmayın!

Sanırım size yardımcı olacak zihniyet, her zaman soyut çözümler yerine kodlama sorunlarına somut çözümler bulmak için gayret göstermektir . Soyutlamalar, yalnızca kod tabanını basitleştirmeye yardımcı olduklarında eklenmelidir (örneğin, kod tabanını küçültmenize izin verdiklerinde).

Soyutlamalar kendi başlarına neredeyse ortaya onlar Birçok programcı bulduk KURU onların kod yukarı. Tasarım Desenleri ve En İyi Uygulamalar, bunu yapmak için fırsatlar bulmanıza yardımcı olur, ancak izlemeye değer hedefler değildir.

Aşırı mühendisliğin çoğu zaman kod yazma konusundaki güvensizlikten kaynaklandığını düşünüyorum. Tüm soyut ilkeler ve desenler size yardımcı olacak araçlar olarak görülmelidir. Sık sık olan, standart olarak kabul edilmeleridir, bunlara uyulmalıdır.

Bir programcının bir aksiyomdan nasıl soyutlanacağına karar vermek için her zaman daha iyi bir konumda olduğuna inanıyorum.

Gerisi zaten KeithS tarafından söylendi

İyi bir tasarımın avantajlarının neler olduğunu kendinize sorun:

• Anlaşılması daha kolay
• Daha kolay korur
• Taşınabilir
• Uzun süre faydalı kalır
• Yeni özellikler eklemek kolaydır

Şimdi, tüm bu soyutlama katmanlarını gerçekten yukarıda belirtilen noktaların herhangi birine ekleyip eklemediğinizi kendinize sorun. Olmazsa , YANLIŞ yapıyorsun .

Bunun gibi 3 satır kod ekleyerek yeni bir özellik ekleyebiliyorsanız:

if (condition()) {
  doSomething()
}

Öyleyse lütfen, lütfen yap. Bu, önceki tasarımınızın uyarlanmasının iyi ve kolay olduğunu gösterir. Yalnızca sınıflarınız belirli bir sürenin ötesinde büyümeye başladığında, işlevleri bölmek ve muhtemelen yeni sınıflar çıkarmak için refactoring kullanın.

Benim temel kuralım, yeni özelliklerin mümkün olduğunca minimalist bir şekilde uygulanması gerektiğidir, yalnızca bir şeyi önceden kavramak büyük olduğunda (diyelim, uygulamak için 1 gün veya yarım günden daha uzun sürüyorsa) kaba bir global tasarım ekleyebilirsiniz. Oradan, yalnızca kodun boyutu büyüdüğünde soyutlama katmanları ekleyin. Daha sonra daha sonra refactor! Bir süre sonra, biraz daha fazla parça tasarlamanız gerektiğinde ya da hızlı yola gitmeniz gerektiğinde size doğal gelmelidir. Bazı kodların, bazı temizlik işlemlerini kullanabileceği bir başka gösterge, onu yeniden kullanmanızdır. Her yeni bir özellik eklediğinizde veya eski kodu yeni bir yerde aradığınızda, eski koda bakmak ve onu yeniden eklemeden önce biraz geliştirip geliştiremeyeceğinizi görmek için iyi bir zaman. Bu şekilde, sıcak kod yavaş yavaş daha temiz bir hale gelirken, ilginç kısımlar yavaşça çürür ve değerli zamanınızı hiç almazsınız.

Böyle çalışırsan, hiçbir zaman fazla tasarım yapamazsın. Yeni bir şey eklemek istediğinizde eski koda geri dönmek veya istediğiniz zaman biraz daha çirkin bir şekilde yeni bir kod bırakmak biraz disiplin gerektirebilir, ancak daha fazla mühendislik yerine verimli bir şeye doğru çalışacaksınız.