Kişi sürdürülebilirliği nasıl anlamlı bir şekilde ölçüyor?

Bağlam: Ben bir all-MS mağazasında bir kurumsal geliştirici değilim.

Herkes bir kod parçasının veya uygulamanın bakımını objektif olarak ölçmenin iyi bir yolunu önerebilir mi?

Neden sürdürülebilirlik : Grubumdaki "kalite" ölçümlerinden yalnızca hatalar ve kod kapsamı etrafında dönen yoruldum. Her iki ölçümün de, özellikle de sürdürülebilirliği ölçemediğiniz zaman oynamak kolaydır. Kısa görüşlülük ve son teslim tarihleri, hiç bir zaman gerçekten ele alınamayan büyük miktarda teknik borçla sonuçlanır.

Neden nesnel olarak ölçme kabiliyeti : Büyük bir işletme grubunda çalışıyorum. Nesnel olarak ölçemezseniz, insanları bu konuda sorumlu tutamazsınız veya daha iyi hale getirmelerini sağlayamazsınız. Öznel ölçümler gerçekleşmez veya tutarlı bir şekilde gerçekleşmez.

VS2010 kod metriklerine bakıyorum , ancak başka bir tavsiyesi olan var mı merak ediyorum.

Ölçülebilirliği ölçen ihtar, geleceği tahmin etmeye çalıştığınız anlamına gelir. Kod kapsamı, hata sayımı, LOC, çevrimsel karmaşıklık hepsi şu anla ilgilidir .

Gerçek şu ki, kodun olduğu gibi bakımı yapılamayacağına dair somut kanıtınız yoksa… eee… bir hatayı düzeltmek, sürdürülemeyen kod nedeniyle N saatlerce gerekmeyen zamana sebep oldu; o zaman ayakta durmak için bir bacağın olması doğal olarak zor olacaktır. Bu örnekte, daha basit bir şeyin yeterli olacağı durumlarda aşırı karmaşık bir metodolojinin kullanılması gerçeğinden kaynaklanmış olabilir. Metodolojileri, paradigmaları ve en iyi uygulamaları ölçmeye çalıştığınız bir alana müdahale etmek, çok az veya hiç uzun vadeli kazanç elde etmeden giderek daha zor hale gelir.

Bu yoldan gitmek maalesef hiçbir yere giden bir yoldur. Temel haklara sahip ve kod tabanındaki adlandırma kurallarının eksikliği gibi bir sorun hakkında kişisel duygulara bağlı olmayan kök sorunları ortaya çıkarmaya odaklanın ve bu kök sorundaki başarı ve başarısızlıkları ölçmenin bir yolunu bulun. Bu, daha sonra etrafta çözümler üretmeye başlayabileceğiniz bir dizi yapı taşı oluşturmaya başlamanıza izin verecektir.

Peki, kullandığım veya kullandığımı düşünmek istediğim ölçü şu:

Her bağımsız, tek, tek satırlık, kullanıma hazır ya da bırak işlev gereksinimi için, uygulamadan önce kod tabanının görüntüsünü alın. Ardından, sürece dahil edilen hataları bulmak ve düzeltmek de dahil olmak üzere uygulayın. Ardından diff, önce ve sonra kod tabanı arasında bir sayı çalıştırın . Bu diff, size değişikliği uygulayan tüm eklerin, silmelerin ve değişikliklerin bir listesini gösterecektir. (Ardışık 10 kod satırı eklemek gibi bir değişiklik var.) Kaç tane değişiklik vardı? Bu sayı ne kadar küçükse, kod normalde o kadar iyi korunur.

Buna kaynak kodunun fazlalığı diyorum , çünkü bu bir hata düzeltme kodunun fazlalığı gibi. Bilgi 1 öbek içinde bulunuyordu, ancak tutarlı olması için hepsi bir arada yapılması gereken N öbekleri olarak kodlandı.

DRY'nin arkasındaki fikir bence ama biraz daha genel. Bu sayının düşük olmasının nedeni, tipik bir gereksinimi uygulamak için N değişiklik yapması durumunda ve hatalı bir programcı olarak, ilk önce yalnızca N-1 veya N-2’nin doğru yapılmasını sağlamanızdır. 1 veya 2 böcek. O (N) programlama çabasının tepesinde, bu hataların keşfedilmesi, bulunması ve onarılması gerekir. Bu yüzden küçük N iyidir.

Bakım, kodun nasıl çalıştığını öğrenmemiş bir programcı için mutlaka okunabilir anlamına gelmez. N'yi optimize etmek, programcılar için bir öğrenme eğrisi yaratan bazı şeyler yapmayı gerektirebilir. İşte bir örnek. Yardımcı olan şey, programcının gelecekteki değişiklikleri öngörmeye çalışması ve programın yorumunda nasıl yapılır talimatları bırakmasıdır.

N yeterince azaldığında (optimum değer 1), kaynak kodunun etki alanına özgü bir dil (DSL) gibi daha fazla okuduğunu düşünüyorum. Program, sorunu “belirttiği” kadar çok “çözmez”, çünkü ideal olarak her gereksinim sadece tek bir kod parçası olarak yeniden düzenlenir.

Ne yazık ki, insanların bunu nasıl yapacağını öğrendiklerini göremiyorum. Aksine zihinsel isimlerin sınıf olması gerektiğini ve fiillerin yöntem haline geldiğini düşünüyor gibi görünüyorlar ve tek yapmaları gereken krank çevirmek. Bu benim deneyimim, 30 veya daha fazla N koduyla sonuçlanır.

Bakım yapılabilirlik gerçekten ölçülebilir değildir. Bireyin deneyimlerini ve tercihlerini temel alarak öznel bir görüşü.

Bir kod parçası için mükemmel bir tasarım fikri ile geldi .

O zaman gerçek kodun bu kusursuz olandan herhangi bir sapması için 100 değerini bir sayı kadar azaltın. Tam olarak neyin seçtiği mükemmel olmayan bir yaklaşımın sonuçlarına bağlıdır.

Bir örnek:

Bir kod parçası, bazı veri formatlarını okur ve içe aktarır ve eğer bir sorun varsa, hata mesajı gösterebilir.

Mükemmel bir çözüm (100) ortak bir yerde tutulan hata mesajlarına sahip olacaktır. Çözümünüzde doğrudan kodda dize sabiti olarak kodlanmış kodlar varsa, şunu söyleyin, 15 kapalı. Böylece, sürdürülebilirlik endeksiniz 85 olur.

Korunması zor olan kodun bir sonucu, hataları düzeltmenizin sizi daha uzun ("ortalama") alacağıdır. Bu nedenle, ilk bakışta bir ölçüm, atandığında (yani düzeltme başlatıldığında) bir hatayı "teste hazır" olduğu zamana kadar düzeltmek için harcanan zaman gibi görünecektir.

Şimdi, bu yalnızca “ortalama” (bu ne anlama gelir) zamanı alabilmek için makul sayıda hata düzelttikten sonra gerçekten işe yarayacak. Belirli bir hata için bu rakamı kullanamazsınız, çünkü izlemenin ne kadar zor olduğu kodun sadece "korunabilirliğine" bağlı değildir.

Elbette, daha fazla hata giderdikçe, kod daha iyi hale gelirken (veya en azından olmanız gerektiği gibi) korumak için "kolay" hale gelir ve kodla daha aşina hale gelirsiniz. Buna karşılık, böceklerin daha belirsiz olma eğiliminde olacağı ve dolayısıyla izini sürmek daha da zor olacaktır.

Bu aynı zamanda, eğer insanlar daha düşük bir puan elde etmek için hata düzeltmeleri yapmak için acele etmeye eğilimli olacaklarsa ya da yeni hatalara neden olacak ya da mevcut olanı daha fazla iş ve muhtemelen daha da kötü kodlara yol açacak şekilde düzeltmeyeceklerdir.

Visual Studio Kod Metrikleri'ni hızlı bir "bakım yapılabilirlik" ölçütü sağlamak için oldukça iyi buluyorum. 5 birincil ölçüm yakalanır:

• Cyclomatic karmaşıklık
• Kalıtım Derinliği
• Sınıf Couling
• Kod Satırları (yöntem seviyesine, sınıf başına, proje başına, ne olursa olsun, toparlanma seviyenize bağlı olarak)

Bakım İndeksi kullanışlı olduğumu gösterir. Bu, aşağıdakilere dayanan bileşik bir endeks:

1. Toplam Boyut (Kod Satırı)
2. Sınıf veya Dosya Sayısı
3. Yöntem Sayısı
4. 20'nin üzerindeki Siklomatik Karmaşıklık (veya 10 - yapılandırılabilir, 10 benim tercihim)
5. kopya

Zaman zaman, düşük bir Bakım Kolaylığı Endeksi olan yöntemlerime bakacağım (düşük = bunun için kötü). Neredeyse başarısız olmadan, projemdeki En Düşük Bakım Kolaylığı Endeksine sahip yöntemler, tekrar yazmaya en çok ihtiyaç duyulan ve okunması en zor olanları (veya bakımı en zor olanları).

Hesaplamalar hakkında daha fazla bilgi için beyaz belgeye bakın .

Anlamlı olacak iki döngüsel karmaşıklık ve sınıf birleştirmedir. Karmaşıklığı ortadan kaldıramazsınız, tek yapabileceğiniz şey onu yönetilebilir parçalara bölmektir. Bu 2 önlem size bakımı zor kodun nerede olabileceği veya en azından en zor nereye bakılacağı konusunda bir fikir vermelidir.

Siklomatik karmaşıklık, kodda kaç tane yol bulunduğunun bir ölçüsüdür. Her yol test edilmelidir (ancak muhtemelen değil). 20'nin üzerinde bir karmaşıklığa sahip bir şey daha küçük modüllere bölünmelidir. Sekizlik karmaşıklığı 20 olan bir modül (bunu art arda 20 if then elseblokla kopyalayabilir ), test edilecek 2 ^ 20 yolun üst sınırına sahip olacaktır.

Sınıf birleştirme, sınıfların ne kadar sıkı bağlandığının bir ölçüsüdür. Önceki işverenimde birlikte çalıştığım bazı kötü kodların bir örneği, yapıcıda yaklaşık 30 öğeli bir "veri katmanı" bileşeni içerir. Bu bileşenden çoğunlukla "sorumlu" olan kişi, gerçekten büyük bir çamur toplayana kadar yapıcı / açık çağrılara işletme ve kullanıcı arabirimi katman parametreleri eklemeye devam etti. Eğer bellek bana doğru hizmet ederse, hepsi biraz farklı parametre setleriyle birlikte, yaklaşık 15 farklı yeni / açık çağrı oldu (bazıları artık kullanılmıyor). Tek başına onu daha fazla şey yapmasını engellemek amacıyla kod incelemeleri yaptık - ve onu seçtiğimiz gibi görünmesini engellemek için, ekipteki herkesin kodunu inceledik, bu yüzden 4-6 için yaklaşık yarım gün harcadık insanlar her gün çünkü biz

Alt satırda, bakım gerçekten daha önce değil, yalnızca gerekli olduktan sonra ölçülebilir . Yani, yalnızca bir kod parçasının korunup korunmadığını, ne zaman sürdürmek zorunda olduğunuzu anlayabilirsiniz.

Bir kod parçasını değişen gereksinimlere uyarlamanın ne kadar kolay olduğunu ölçmek açıktır. Önceden imkansız ölçüme, ihtiyaçlardaki değişikliklere nasıl cevap vereceğine yakındır. Bu, gereksinimlerdeki değişiklikleri tahmin etmeniz gerektiği anlamına gelir. Ve bunu yapabilirseniz, bir nobel fiyatı almalısınız;)

Yapabileceğiniz tek şey, hepinizin sürdürülebilirliği arttırdığına inandığınız bir takım somut kurallara (örneğin, SOLID ilkeleri gibi) bağlı olarak ekibinizle aynı fikirde olmaktır.
Eğer prensipler iyi seçilmişse (bence SOLID ile gitmek başlamak için iyi bir seçim olacaktır), ihlal edildiklerini açıkça gösterebilir ve yazarları bundan sorumlu tutabilirsiniz.
Bakımınızı yapmak için mutlak bir önlem almaya çalışırken çok zorlu bir zaman geçireceksiniz ve ekibinizi adım adım gerçekçi bir şekilde belirlenmiş bir ilkeler eki setine sadık kalmaya ikna edin.

Asla ele alınamayan büyük miktarda teknik borç

"Olaylar tarafından üstlenilen" teknik borçtan ne haber?

Berbat bir kod yazıp üretime sokuyorum.

Siz gözlemlediniz - doğru - bu sürdürülemez.

Ancak bu kod, yasal bağlam değiştiğinden ve ürün hattının geleceği olmadığı için hizmetten çıkarılacak bir ürün yelpazesinin son özelliğidir.

"Teknik borç", hepsini eskimiş kılan yasal bir değişiklikle elimine edildi.

"Sürdürülebilirlik" ölçütü, dış değerlendirmeler nedeniyle "kötü" den "alakasız" a geçti.

Bu nasıl ölçülebilir?

Bir eş kod incelemesinde bir sonraki en iyi şey, bir birimi veya ürünü kodlamadan önce çalışılabilir bir mimari oluşturmaktır. Kırmızı-yeşil-refactor bu konuda oldukça temiz bir yol. Bir Sr. çocuğunun birlikte çalışabilir bir arayüz atmasını sağlayın ve çalışmayı kısaltın. Herkes yapbozun parçalarını alabilir ve zafere giden yolu kırmızı-yeşil olarak alabilir. Bundan sonra, bir eş kod incelemesi ve refactor sırayla olurdu. Bu çalıştığım eski bir üründe oldukça iyi çalıştı.

anket

Geliştiricilere ayda bir kez doldurmak için isimsiz bir anket yapmaktan ne haber? Sorular şöyle bir şey olurdu:

• Geçen ayın ne kadar zamanını X projesine harcadınız (kabaca) [0% ... 100%]
• Kod tabanının durumunu sürdürülebilirlik açısından nasıl değerlendirirsiniz [gerçekten fakir, fakir, tarafsız, tamam, iyi, gerçekten iyi].
• Kod tabanını projenin karmaşıklığına kıyasla ne kadar karmaşık olarak değerlendirirsiniz [çok karmaşık, çok doğru, çok basitleştirilmiş].
• Kod üssünün aşırı karmaşıklığından dolayı görevlerinizi çözme konusunda sizi ne sıklıkta engellediniz? [hiç de değil, arada bir, sıklıkla, sürekli olarak].

(Yorumlardaki bakımın ölçülmesinde yararlı olacağını düşündüğünüz ilave sorular eklemekten çekinmeyin, ben de bunları ekleyeceğim.)

Sürdürülebilirliğe bakmak için iki yol düşünebilirim (eminim ki başkaları daha iyi tanımlar bulabilir.

Anlamadan değişiklik.

Bir hata onarım yazılımı kodun içine girip tüm sistemin nasıl çalıştığını anlamadan bir sorunu çözebilir mi?

Bu, kapsamlı birim testleri (regresyon testleri) sağlayarak başarılabilir. Sistemde yapılan herhangi bir değişikliğin, sistemin herhangi bir belirli iyi girdiyle nasıl davrandığını değiştirmediğini kontrol edebilmelisiniz.

Bu durumda, bir hata onarım yazılımı gelip sistemi basit bir şekilde haberi olan (basit) bir hatayı düzeltebilmelidir. Düzeltme çalışıyorsa, regresyon testlerinin hiçbiri başarısız olmamalıdır. Herhangi bir regresyon testi başarısız olursa, o zaman 2. aşamaya geçmeniz gerekir.

maintainabilty1 = K1 . (Code Coverage)/(Coupling of Code) * (Complexity of API)

Anlayışla değiştirme.

Bir hata düzeltme önemsiz hale gelirse ve sistemi anlamanız gerekiyorsa. Öyleyse sistemin belgeleri nasıldır? Biz edilir değil dış API belgelerine konuşurken (nispeten yararsız). Anlamamız gereken şey, sistemin uygulamalarda kullanılan herhangi bir zeki (okuma hack) hilesi olduğu yerlerde nasıl çalıştığıdır.

Ancak dokümantasyon yeterli değil, kodun açık ve anlaşılabilir olması gerekiyor. Bir kodun anlaşılabilirliğini ölçmek için küçük bir numara kullanabiliriz. Geliştirici kodlamayı bitirdikten sonra, başka bir şey üzerinde çalışması için ona bir ay verin. Ardından, geri gelmelerini ve sistemi bir iskelenin sistemi anlayabileceği ölçüde belgelemelerini isteyin. Eğer kodun anlaşılması nispeten kolaysa, hızlı olması gerekir. Kötü yazılmışsa, neyi yaptıklarını hesaplamaları ve belgeleri yazmaları daha uzun zaman alacaktır.

Öyleyse belki bununla ilgili bir ölçü alabiliriz:

maintainability2 = K2 . (Size of doc)/(Time to write doc)

Sıklıkla "en kısa eşdeğer" çözümün en fazla korunma eğiliminde olduğunu buluyorum.

Burada en kısa, en az işlem olduğu anlamına gelir (satırlar değil). Ve eşdeğer, kısa çözümün önceki çözümden daha kötü zamana veya mekan karmaşıklığına sahip olmaması gerektiği anlamına gelir.

Bu, tüm mantıksal olarak benzer tekrar eden modellerin uygun soyutlamaya çıkarılması gerektiği anlamına gelir: Benzer kod blokları? İşleve çıkarın. Birlikte ortaya çıkan değişkenler? Onları bir yapı / sınıfa çıkarın. Üyeleri yalnızca türe göre farklılık gösteren sınıflar? Bir jenere ihtiyacınız var. Birçok yerde aynı şeyi yeniden hesaplıyor gibisin? Başlangıçta hesaplayın ve değeri bir değişkende saklayın. Bunları yapmak daha kısa kodla sonuçlanacaktır. Temelde DRY prensibi budur.

Kullanılmayan soyutlamaların silinmesi gerektiği konusunda hemfikiriz: sınıflar, artık ihtiyaç duyulmayan fonksiyonlar ölü koddur, bu yüzden kaldırılmalıdır. Sürüm kontrolü, onu tekrar eski durumuna getirmemiz gerekip gerekmediğini hatırlayacaktır.

Sıkça tartışılan şey, yalnızca bir kez referans verilen soyutlamalardır: bir defadan fazla çağrılmak için hiçbir neden olmadan yalnızca bir kez çağrılan geri çağırma işlevleri. Yalnızca bir tür kullanılarak başlatılmış bir jenerik ve başka bir türle başlatılmış olması için hiçbir neden yok. Sadece bir kez uygulanan arayüzler ve bunun başka bir sınıf tarafından uygulanmasının gerçek bir nedeni yoktur. Bu şeylerin gereksiz olduğu ve kaldırılması gerektiği kanısındayım, bu temelde YAGNI ilkesi.

Bu yüzden kod tekrarını belirleyebilecek bir araç olmalı, ancak sorunun, kararsız olan Kolmogorov karmaşıklık problemi olan optimal sıkıştırma bulmaya benzer olduğunu düşünüyorum. Ancak diğer ucunda kullanılmayan ve kullanılmayan soyutlamalar referans sayısına göre tespit etmek kolaydır: bunun için bir kontrol otomatikleştirilebilir.

Hepsi özneldir ve kodun kendisine dayanan herhangi bir ölçüm sonuçta önemsizdir. Sonunda talepleri yerine getirme yeteneğinize iniyor. Talep edilen özellikleri hala sunabiliyor musunuz ve eğer yapabiliyorsanız, bu değişiklikler size ne sıklıkla geri dönecek çünkü bir şey henüz doğru değil ve bu konular ne kadar ciddi?

Sürdürülebilirliği sadece (yeniden) tanımladım, ancak yine de öznel. Öte yandan, bu kadar önemli olmayabilir. Sadece müşterimizi memnun etmemiz ve zevk almamız gerekiyor, hedeflediğimiz şey bu.

Belli ki patronunuza veya iş arkadaşlarınıza, kod tabanının durumunu iyileştirmek için bir şeyler yapılması gerektiğini kanıtlamanız gerektiğini hissediyorsunuz. Tartışmanız gereken her küçük şey için, kaçınılabilecek diğer 10 sorunu çözmeniz ya da çalışmanız gerektiği gerçeğinden dolayı hayal kırıklığına uğradığınızı söylemeniz yeterli olacaktır. Sonra ünlü bir bölgeyi adlandırın ve ters çevirmek için bir dava açın. Bu, ekibinizde herhangi bir destek sağlamazsa, başka bir yerde daha iyi olabilirsiniz. Etrafınızdaki insanlar umursamıyorsa, amacınızı ispatlamak fikrini değiştirmeyecektir.