Macarca notasyonu kullanmamanın faydası nedir?

Mücadele ettiğim şeylerden biri Macar gösterimini kullanmamak. Ben yok , sadece ne olduğunu tip görmek için değişken tanımına gitmek zorunda istiyorum. Bir proje genişlediğinde, 'bool' ile önceden belirlenmiş bir değişkene bakmak ve 0/1 değeri yerine doğru / yanlış aradığını bilmek güzel .

Ayrıca SQL Server'da da çok iş yapıyorum. Değişkenlerimi sırasıyla veritabanında belirtmemek için saklı yordamlarımı 'sp' ile ve tablolarımı 'tbl' ile öneklendiriyorum.

Her yerde, kimsenin Macar gösterimini kullanmak istemediği, kaçındıkları bir noktaya geldiğini görüyorum. Sorum ne faydası vardır değil Macar gösterimi kullanarak ve neden geliştiricilerin çoğunluğu veba gibi önlemek geliyor?

Çünkü onun orjinal niyeti (bkz. Http://www.joelonsoftware.com/articles/Wrong.html ve http://fplanque.net/Blog/devblog/2005/05/11/hungarian_notation_on_steroids ) yanlış anlaşıldı ve oldu ( ab) kullandıkları dil statik olarak yazılmadığında, bir değişkenin ne tür olduğunu hatırlamalarına yardımcı olmak için kullanılır. Statik olarak yazılmış herhangi bir dilde, bir değişkenin ne tür olduğunu söylemek için ek ön eke ihtiyacınız yoktur. Yazılmamış betik dillerinde yardımcı olabilir, ancak genellikle tamamen hantal olma noktasına gelince suistimal edildi. Maalesef, Macar gösteriminin asıl amacına geri dönmek yerine, insanlar bunu kaçınmanız gereken "kötülük" şeylerinden birine dönüştürmüşlerdir.

Kısaca Macar gösterimi, bazı anlambilimsel değişkenleri öneklemekti. Örneğin, ekran koordinatlarınız varsa (sol, üst, sağ, alt), " abs" ile mutlak ekran konumlu değişkenleri ve " " ile bir pencereye göre konumlu değişkenleri öneklendirirsiniz rel. Bu şekilde, mutlak pozisyonları gerektiren bir yönteme göreceli bir koordinat verdiğinizde herhangi bir okuyucu için açık olacaktır.

güncelleme (delnan tarafından yapılan yoruma yanıt olarak)

IMHO kötüye kullanılan sürüm veba gibi kaçınılmalıdır, çünkü:

• isimlendirmeyi zorlaştırıyor. (Ab) Macarca notasyonu kullanırken, her zaman öneklerin ne kadar spesifik olması gerektiğine dair tartışmalar olacaktır. Örneğin: listboxXYZveya MyParticularFlavourListBoxXYZ.
• değişkenin ne için olduğunu anlamadan, değişken isimlerini daha uzun hale getirir.
• uzun öneklerden kaçınmak için bunlar kısaltmalara kısaltıldığında ve her bir kısaltmanın ne anlama geldiğini bilmek için bir sözlüğe ihtiyaç duyduğunuzda alıştırmanın nesnesini yener. Bir mi uiişaretsiz tamsayı? kayda değer sayılmamış bir arayüz? kullanıcı arayüzleri ile ilgisi var mı? Ve bu şeyler uzayabilir . Var türünü tam olarak iletmesi beklenen, ancak gerçekten yalnızca gizemli olan, görünüşte rastgele 15 karakterden oluşan önekleri gördüm.
• hızlı güncelliğini yitirir. Bir değişkenin türünü değişmez bir şekilde değiştirdiğinizde (lol) değişikliği yansıtmak için ön eki güncellemeyi unutur ya da kasıtlı olarak güncellemeyin, çünkü bu her yerde kullanılan kod değişikliklerini tetikler ...
• kod hakkında konuşmayı zorlaştırır çünkü "@g." Dedi ki: Macar notasyonuna sahip değişken isimler tipik olarak telaffuz edilmesi zor alfabe çorbasıdır. Bu okunabilirliği ve kod tartışmasını engeller, çünkü isimlerin hiçbirini 'söyleyemezsiniz'.
• ... şu anda hatırlayamadığım çok şey var. Belki de uzun süredir istismar edilen Macar gösterimi ile uğraşmamak zorunda kaldığım için zevk aldım ...

Macarca notasyon, günümüz programlama ortamlarında ve Tautology formunda adlandırma karşıtı bir kalıptır .

İşe yaramaz bir şekilde ek bir bakım ve ek bakım gerektirmeden bilgileri tekrarlar. Sizi intfarklı bir türe dönüştürdüğünüzde ne olur long, şimdi tüm değişkenleri yeniden adlandırmak için tüm kod tabanınızı aramanız ve değiştirmeniz gerekir veya bunlar, adın türünü kopyalamamış olmanızdan daha kötü olan şu an anlamsal olarak yanlıştır.

KURU ilkesini ihlal ediyor. Eğer veritabanı tablolarınızı bir tablo olduğunu hatırlatmak için bir kısaltma ile önceden belirtmek zorunda kalırsanız, o zaman kesinlikle tablolarınızı anlamsal olarak yeterince tanımlayıcı olarak adlandırmazsınız. Aynısı, bunu yaptığınız diğer her şey için de geçerli. Modern bir geliştirme ortamı ile kazanç sağlamak veya fayda sağlamak için sadece fazladan yazma ve çalışmadır.

Vikipedi Macar gösteriminin avantaj ve dezavantajlarının bir listesine sahiptir ve bu nedenle muhtemelen bu sorunun en kapsamlı cevabını sağlayabilir. Dikkate değer opinons de oldukça ilginç bir okuma vardır.

Faydası olmayan Macar notasyonu kullanarak dezavantajları temelde sadece kaçınma geçerli:

• Macar gösterimi, derleyici tarafından tip kontrolü yapıldığında gereksizdir. Tip kontrolü sağlayan diller için olan derleyiciler, bir değişkenin kullanımının otomatik olarak türüyle tutarlı olmasını sağlar; gözle yapılan kontroller gereksizdir ve insan hatası olabilir.

• Tüm modern Entegre geliştirme ortamları isteğe bağlı olarak değişken tipler gösterir ve uyumsuz tipler kullanan işlemleri otomatik olarak işaretler ve gösterimi büyük ölçüde eskimiş yapar.

• Macar Notasyonu, aşağıdaki gibi çeşitli özellikleri temsil etmek için kullanıldığında kafa karıştırıcı hale gelir a_crszkvc30LastNameCol: sabit bir referans argümanı, tablonun birincil anahtarının bir parçası olan LastNametipte bir veritabanı kolonunun içeriğini tutar varchar(30).

• Kod değiştirildiğinde veya taşındığında tutarsızlığa neden olabilir. Bir değişkenin türü değiştiyse, değişkenin adındaki dekorasyon yeni türle tutarsız olur veya değişkenin adı değiştirilmelidir. Özellikle iyi bilinen bir örnek, standart WPARAMtürdür ve wParampek çok Windows sistem işlevi bildiriminde eşlik eden biçimsel parametredir. 'W', 'word' anlamına gelir; burada 'word', platformun donanım mimarisinin yerel word boyutudur. Orijinal olarak 16 bit kelime mimarileri için 16 bit bir türdü, ancak işletim sisteminin sonraki sürümlerinde korunarak, 32 bit kelime mimarileri için 32 bit veya 64 bit kelime mimarileri üzerinde 64 bit türü olarak değiştirildi. orijinal ad (gerçek temel tipiUINT_PTRyani, bir işaretçiyi tutacak kadar büyük, işaretsiz bir tam sayı). Anlamsal empedans ve dolayısıyla programcının platformdan platforma kargaşası ve tutarsızlığı, 'w' nin bu farklı ortamlarda 16-bit anlamına geldiği varsayımı üzerinedir.

• Bir değişkenin kullanımını bilmek çoğu zaman türünü bilmek anlamına gelir. Ayrıca, bir değişkenin kullanımı bilinmiyorsa, türünden çıkarılamaz.

• Macarca notasyonu, değişken isimler üzerinde tamamlamayı destekleyen, zengin özellikli kod editörlerinin kullanılmasının faydalarını kuvvetle azaltır, çünkü programcının ilk önce bütün tip belirticisini girmesi gerekir.

• Değişkenin amacını gereksiz tip ve kapsam önekleriyle karıştırmak suretiyle kodu daha az okunabilir hale getirir.

• Ek tür bilgisi, daha açıklayıcı adların yerine geçemez. Örneğin sDatabase, okuyucuya ne olduğunu söylemez. databaseNamedaha açıklayıcı bir isim olabilir.

• Adlar yeterince açıklayıcı olduğunda, ek tür bilgisi gereksiz olabilir. Örneğin firstName, büyük olasılıkla bir dizedir. Bu yüzden isimlendirme sFirstNamesadece koda karmakarışıklık ekler.

Ben bu gösterimi kendim kullanmıyorum, çünkü gereksiz teknik gürültüyü sevmiyorum. Neredeyse her zaman hangi türle uğraştığımı biliyorum ve etki alanı modelimde temiz bir dil istiyorum, ancak çoğunlukla statik ve çok yazılan dillerde yazıyorum.

MS SQL Server'a özgü bir sorun olarak:

'Sp_' ile önceden saklanmış tüm saklı yordamlar ilk önce oluşturuldukları yerine Ana veritabanında aranır. Bu saklı yordamın yürütülmesinde gecikmeye neden olur.

IMO, Macarcayı kullanmamanın en büyük yararı, sizi anlamlı isimler kullanmaya zorlamasıdır . Değişkenleri doğru bir şekilde adlandırıyorsanız, ne tür olduğunu derhal bilmelisiniz veya iyi tasarlanmış herhangi bir sistemde oldukça hızlı bir şekilde çıkarabilirsiniz. İtimat gerekiyorsa strveya blnhepsinden ya da kötü objkötü değişken genel adları veya anlam iletmek için yol çok jenerik ya - bir değişkendir ne tür bilmek önekleri, ben bir adlandırma sorunu olduğunu gösterir iddia ediyorum.

İronik olarak, kişisel deneyimimden Macarca’nın kullandığı ana senaryo ya “kargo kültü” programlama (yani diğer kod kullanıyor, bu yüzden sadece kullanmaya devam edelim) ya da VB.NET’de dilin olduğu gerçeği üzerinde çalışmak için. büyük / küçük harfe duyarsız (örneğin Person oPerson = new Personkullanamadığınız Person person = new Personve Person p = new Personçok belirsiz olduğunuz için); Ayrıca, bu durumda "veya" veya "benim" ön ekini de gördüm (içinde Person thePerson = new Personveya çirkin Person myPerson = new Person).

Macarca kullandığım tek zamanı ekleyeceğim, ASP.NET kontrolleri olma eğilimindeydi ve bu gerçekten bir seçim meselesi. Ben çok çirkin yazmaya bulmak TextBoxCustomerNameveya CustomerNameTextBoxdaha basit karşı txtCustomerName, ama bu bile "kirli" hissediyor. Hissettiğim bazı aynı verileri görüntülemek çoklu kontroller olabilir gibi adlandırma kuralı tür kontroller için kullanılmalıdır.

Bahsettiğinizden beri sadece SQL Server'a odaklanacağım. 'Tbl' ı masanın önüne koymak için hiçbir sebep görmüyorum. Herhangi bir tSQL koduna bakabilir ve bir tabloyu nasıl kullanıldığını ayırt edebilirsiniz. Sen asla Select from stored_procedure.veya Select from table(with_param)bir UDF olur ya da benzeri Execute tblTableOrViewNamebir saklı yordam gibi.

Tablolar bir Görünüm ile karıştırılabilir, ancak bunların nasıl kullanıldığı ile ilgili olarak; fark yok, peki nokta ne? Macarca notasyonu size SSMS'de arama yapma zamanını kazandırabilir (tablo veya görünümler altında?), Ama bu konuda.

Değişkenler bir sorun yaratabilir, ancak bildirilmeleri gerekir ve gerçekten, beyan deyiminizden ne kadar uzakta bir değişken kullanmayı planlıyorsunuz? Birkaç satır kaydırmak, çok uzun yordamlar yazmadığınız sürece büyük bir anlaşma olmamalıdır. Uzun kodları biraz kırmak iyi bir fikir olabilir.

Tanımladığınız şey bir acıdır, ancak Macar Notasyonu çözümü sorunu gerçekten çözmez. Başkasının koduna bakabilir ve şimdi değişken adında bir değişiklik gerektiren değişken türünün değişebileceğini görebilirsiniz. Unutman gereken bir şey daha var. Ve eğer bir VarChar kullanırsam, boyutlarını bilmek için zaten beyan beyanına bakmanız gerekecek. Açıklayıcı isimler muhtemelen sizi daha da ileriye götürecektir. @PayPeriodStartDate hemen hemen kendisini açıklar.

Eklemek başka bir şey, .NET gibi bir çerçeve için hangi kısaltmaları kullanırsınız ki? Evet, btnbir düğmeyi ve txtbir metin kutusunu temsil ettiğini hatırlamak çok basit . Ancak, böyle bir şeyin aklında ne var StringBuilder? strbld? Ne hakkında CompositeWebControl? Böyle bir şey kullanıyor musunuz:

CompositeWebControl comWCMyControl = new CompositeWebControl();

Macar gösteriminin yetersizliklerinden biri, daha büyük ve daha büyük çerçevelere sahip olmakla, sadece ekstra fayda sağlamakla kalmayıp, aynı zamanda geliştiricilere daha fazla karmaşıklık eklemek olduğunu, çünkü standart dışı ön ekleri daha fazla öğrenmek zorunda kalmalarıydı.

Bazı şeylere bakma biçimimde, Macar Notasyonu, yeterince güçlü olmayan bir tip sistemde dolaşmak için bir çamur. Kendi türlerinizi tanımlamanıza izin veren dillerde, beklediğiniz davranışı kodlayan yeni bir tür oluşturmak oldukça önemlidir. Joel Spolsky'nin Macar Notasyonu üzerine yazdığı rantta, bir değişkenin veya işlevin güvensiz (biz) veya güvenli (ler) olduğunu belirten olası XSS ​​saldırılarını tespit etmek için kullanmaya bir örnek verir, ancak yine de görsel olarak kontrol etmek için programcıya güvenir. Bunun yerine genişletilebilir bir tür sisteminiz varsa, yalnızca iki yeni tür oluşturabilirsiniz: UnsafeString ve SafeString ve bunları uygun şekilde kullanabilirsiniz. Bir bonus olarak, kodlamanın türü:

SafeString encode(UnsafeString)

ve UnsafeString'in içindekilere erişmek veya başka bazı dönüştürme işlevlerini kullanmaktan kaçınmak, UnsafeString’ten bir SafeString’e geçmenin tek yoludur. Tüm çıkış işlevleriniz yalnızca SafeString örneklerini alırsa, çıkmayan bir dize ([StringToSafeString (someUnsafeString.ToString ()) gibi) dönüşümleri olan barmenleri engellemek) çıkarmak imkansız hale gelir.

Bu nedenle, tip sistemin kodunuzu kontrol etmesine izin vermenin, elle veya belki de bu durumda göze bakmaktan daha üstün olduğunun açık olması gerekir.

Tabii ki C gibi bir dilde, int'nin int'nin int olduğu ve bu konuda yapabileceğiniz fazla bir şey olmadığı konusunda mahvoldunuz. Her zaman yapılara sahip oyunlar oynayabilirsiniz, ancak bunun bir gelişme olup olmadığı tartışmalıdır.

Macar Notasyonunun diğer yorumuna gelince, IE değişkeninin türünü öneklendirir, bu sadece salakça bir aptaldır ve countOfPeople gibi anlamlı bir şey yerine uivxwFoo değişkenlerini adlandırma gibi tembel uygulamaları teşvik eder.

Macarca notasyonu, statik olarak yazılmış bir dilde neredeyse tamamen işe yaramaz. Fareyi üzerine koyarak veya başka yollarla bir değişkenin türünü göstermek temel bir IDE özelliğidir; üstelik tür çıkarımı yoksa, ilan edildiği yerde birkaç satır yukarı bakarak türün ne olduğunu görebilirsiniz. Yazım çıkarımının bütün noktası, her yerde tekrarlanan yazımın gürültüsüne sahip olmamaktır, bu nedenle macar notasyonu genellikle yazım çıkarımı olan dillerde kötü bir şey olarak görülür.

Dinamik olarak yazılmış dillerde, bazen yardımcı olabilir, ama bana göre bu unidiomatic hissediyor. İşlevlerinizi tam olarak etki alanları / kod alanlar ile sınırlandırılmış olmaktan zaten vazgeçtiniz; Eğer tüm değişkenleriniz macar notasyonu ile isimlendirilmişse, o zaman sadece bir tip sistemin size vereceği şeyi yeniden üretirsiniz. Macar gösteriminde bir tamsayı olabilen bir polimorfik değişkeni veya dizgiyi nasıl ifade edersiniz? "IntStringX"? "IntOrStringX"? Macar gösterimini kullandığım tek yer, montaj koduydu, çünkü bir tür sisteme sahip olsaydım alacağımı geri almaya çalışıyordum ve kodladığım ilk şeydi.

Her neyse, insanların değişkenlerini adlandırdıkları şeyleri daha az önemseyebilirim, kod muhtemelen yine de anlaşılmaz olacak. Geliştiriciler, stil ve değişken isimleri gibi şeylere çok fazla zaman harcıyor ve günün sonunda, kendi dilinizde tamamen farklı sözleşmelere sahip bir ton kütüphaneye sahip oluyorsunuz. Orada çünkü değişkenler (ama çoğu değişkenler hala önerilen isme sahip adlarını hiçbir değişken adları, yalnızca benzersiz tanımlayıcı daha bulunmaktadır dili, ve önerilen: Ne sembolik (metne dayalı olmayan yani) geliştiriyorum basitçe yok için makul bir ad onlara); Güvenilmeyen kodu denetlerken, değişken adlarına bağlı olamazsınız.

Bu durumda her zaman olduğu gibi, diğer katılımcıların cevaplarını okumadan önce bir cevap göndereceğim. 

Vizyonunda üç "böcek" görüyorum: 

1) Eğer bir değişken / parametre / öznitelik / sütun türünü bilmek istiyorsanız, farenizi farenin üzerine getirebilir veya üzerine tıklayabilirsiniz ve çoğu modern IDE'de görüntülenir. Hangi araçları kullandığınızı bilmiyorum, ama geçen sefer bu özelliği sağlamayan bir ortamda çalışmak zorunda kaldım, 20. yüzyıldaydı, dil COBOL'du, hayır, Fortran ve patronum neden ayrıldığımı anlamadım. 

2 / Tipler gelişim döngüsü boyunca değişebilir. 32 bitlik bir tamsayı, bir noktada 64 bitlik bir tamsayı olabilir, projenin başlangıcında algılanamayan iyi nedenlerden dolayı. Bu nedenle, intX'i longX olarak yeniden adlandırmak veya yanlış tipe işaret eden bir adla bırakmak kötü bir karışımdır. 

3) İstediğiniz şey aslında bir fazlalık. Artıklık çok iyi bir tasarım deseni veya alışkanlık değildir. İnsanlar bile fazla fazlalık konusunda isteksizdir. İnsanlar bile fazla fazlalık konusunda isteksizdir. 

Macarca korkunç bir ihtiyaç içinde olmak bir belirti olduğunu düşünüyorum .
Çok fazla küresel değişkene veya ... elde edilebilirliği çok uzun olan işlevlere sahip olma belirtisi .

Değişken tanımınız görünmüyorsa, genellikle sorunla karşılaşırsınız.
Ve eğer işlevleriniz unutulmaz bir kongre yapmıyorsa , yine orada büyük sorun var.

Bu ... pek çok işyerinin neden ön plana çıktığını açıklıyor sanırım.

Bu üzerinde kökenli dillerin gerekli it. Küresel değişkenlerin olduğu
zamanlarda bonanza . (alternatiflerin yetersizliği nedeniyle)
Bize iyi hizmet etti.

Bugün bunun için elimizde olan tek kullanımıdır Joel Spolsky biri . Değişkenin belirli niteliklerini
takip etmek , güvenliği gibi .

( örneğin “Değişkenin safeFoobarbir SQL sorgusuna enjekte edilecek yeşil bir ışığı var mı ?
- Adı olduğu gibi safe, evet”)

Diğer bazı cevaplar, üzerinde dururken değişken değişken türünü görmeye yardımcı olan editör işlevlerinden bahsetti. Benim düşünceme göre, bunlar da kod aklı için oldukça sorunlu . Ben sadece yeniden yapılanma amaçlı olduğu gibi, diğer birçok özellik gibi (katlama fonksiyonu gibi) ve yeni kodda kullanılmaması gerektiğine inanıyorum.

Macar gösterimini kullanmama nedenlerinin diğer posterler tarafından iyi karşılandığını düşünüyorum. Onların yorumlarına katılıyorum.

Veritabanlarında, nadiren kodda kullanılan, ancak aksi takdirde ad alanlarında çarpışan DDL nesneleri için Macar gösterimini kullanıyorum. Temel olarak bu, ön ek indekslerine iner ve türleriyle (PK, UK, FK ve IN) kısıtlamaları adlandırır. Bu nesneleri adlandırmak için tutarlı bir yöntem kullanın; meta verileri sorgulayarak bazı doğrulamaları çalıştırabilmelisiniz.

Kaçınılmasının nedeni, DRY'yi ihlal eden Macar sistemleridir (önek tam olarak derleyicinin ve (iyi) bir IDE'nin türetebileceği türdür)

değişkenin kullanımı ile macar OTOH öneklerini uygulamalar (yani scrxMouse ekrandaki balta koordinatıdır, bu bir int, kısa, uzun veya hatta özel bir tür olabilir (typedefs bile kolayca değiştirmenize izin verir))

Sistemlerin yanlış anlaşılması Macarları en iyi uygulama olarak yok eden şeydir.

Diyelim ki böyle bir yöntemimiz var (C # da):

int GetCustomerCount()
{
    // some code
}

Şimdi kodda şöyle diyoruz:

var intStuff = GetCustomerCount();
// lots of code that culminates in adding a customer
intStuff++;

İnt bizi çok söylemez. Bir şeyin int olduğu tek gerçek, içinde ne olduğunu bize söylemiyor. Şimdi farz edelim, onun yerine şöyle diyoruz:

var customerCount = GetCustomerCount();
// lots of code that culminates in adding a customer
customerCount++;

Şimdi değişkenin amacının ne olduğunu görebiliriz. Bir int olduğunu biliyor olmamızın bir önemi var mı?

Macarca'nın asıl amacı, bunun gibi bir şey yapmanızı sağlamaktı:

var cCustomers = GetCustomerCount();
// lots of code that culminates in adding a customer
cCustomers++;

Bu, c'nin ne anlama geldiğini bildiğiniz sürece iyidir . Fakat standart bir ön ekler tablosuna sahip olmanız gerekirdi ve herkes bunları bilmek zorunda kalacak ve herhangi bir yeni insan kodunuzu anlamak için bunları öğrenmek zorunda kalacaktı. Oysa customerCountveya countOfCustomersilk bakışta oldukça açıktır.

Macarların daha önce Option Strict OnVB'de bir amacı vardı, çünkü VB6 ve öncesinde (ve VB. NET'te Option Strict Off) VB zorlardı, bu yüzden bunu yapabilirdiniz:

Dim someText As String = "5"
customerCount = customerCount + someText

Bu kötü, ama derleyici sana söylemedi. Bu yüzden, eğer Macarca kullandıysanız, en azından ne olduğunun bir göstergesi olacak:

Dim strSomeText As String = "5"
intCustomerCount = intCustomerCount + strSomeText  // that doesn't look right!

.NET'te statik yazarken, bu gerekli değildir. Macarca da, iyi isimlendirmenin yerini tutamazdı. Macarca'yı unut ve yerine iyi isimler seç.

Ergonomi aleyhine çok iyi argümanlar buldum ama bir tane görmedim.

Eski zamanlarda, sahip olduğunuz her şey string, int, bool ve float olduğunda, sibf karakterleri yeterli olurdu. Fakat string + short ile problemler başlar. Önek için tam ad mı, dize için str_name mi kullanın? (İsimler neredeyse her zaman dizge olsalar da değil mi?) Sokak sınıfının nesi var? Adlar uzadıkça uzar ve CamelCase'i kullansanız bile, tür önekinin nerede bittiğini ve değişken isminin nerede başladığını söylemek zordur.

 BorderLayout boderLayoutInnerPanel = new BorderLayout ();
 panelInner.addLayout (borderLayoutInnerPanel);

Tamam - eğer zaten başka bir şey için kullanmazsanız alt çizgileri kullanabilir veya alt çizgileri çok uzun süre kullandıysanız CamelCase'i kullanabilirsiniz:

 BorderLayout boderLayout_innerPanel = new BorderLayout ();
 panel_inner.addLayout (borderLayout_innerPanel);

 Border_layout boder_layoutInner_panel = new Border_layout ();
 panelInner.add_layout (border_layoutInner_panel);

Çok canavarca ve sonuçta yaparsan, sahip olacaksın.

 for (int iI = 0; iI < iMax-1; ++iI)
     for (int iJ = iI; iJ < iMax; ++iMax) 
          int iCount += foo (iI, iJ); 

Her iki döngü değişkeni gibi önemsiz durumlar için işe yaramaz önekler kullanmaya son vereceksiniz count. Son zamanlarda ne zaman bir sayaç için kısa ya da uzun kullandınız? İstisnalar yaparsanız, bir ön eke ihtiyaç olup olmadığını düşünerek sık sık zaman kaybedersiniz.

Çok fazla değişkeniniz varsa, normalde IDE'nizin bir parçası olan nesne tarayıcıda gruplandırılırlar. Şimdi% 40 int için i_, dize için s_ ile% 40 başlar ve alfabetik olarak sıralanırsa, adın önemli bir bölümünü bulmak zordur.

Düzenli olarak Macarca veya benzer son ekleri kullandığım tek yer, aynı anlamsal verilerin veri dönüştürme gibi iki farklı biçimde bulunduğu bağlamlardadır. Bu, çoklu ölçüm birimlerinin olduğu veya çoklu formların olduğu durumlarda olabilir (örneğin, String "123" ve integer 123).

Macarca'yı başkalarına empoze etmemek için zorlayıcı kullanmamaları için verilen sebepleri bulmak , ancak kendi uygulamanıza karar vermek için sadece hafif düşündürücü buluyorum .

Bir programın kaynak kodu , kendi sağında bulunan bir kullanıcı arayüzüdür - algoritmaları ve meta verilerini koruyucusuna sergiler - ve kullanıcı arayüzlerinde fazlalık bir günahtır, bir erdemdir . Örneğin, " Gündelik Şeylerin Tasarımı " bölümündeki resimlere bakın ve "Çekme" etiketli kapılara, onları çekmiş gibi görünün ve biraya bakın, operatörler önemli nükleer reaktör kontrollerine hapsoldu çünkü bir şekilde "üzerinden geçti IDE'de onları "yeterince iyi değildi.

"Sadece bir IDE hover" dir değil sadece bir sebep - Macar kullanmak için bir neden bazı insanlar yararlı bulmak olmayabilir. Kilometreniz değişebilir.

Macarca'nın değişken tipler değiştiğinde önemli bir bakım yükü getirdiği fikri aptalca - değişken tiplerini ne sıklıkla değiştirirsiniz? Ayrıca, değişkenleri yeniden adlandırmak kolaydır:

Tüm olayları yeniden adlandırmak için IDE'yi kullanmanız yeterli. -Gander, Goose'a cevap veriyor

Macarca gerçekten hızlı bir şekilde bir parça kodunu almanıza ve güvenilir bir şekilde korumanıza yardımcı oluyorsa, onu kullanın. Eğer değilse, yapma. Diğer insanlar size kendi deneyimleriniz konusunda yanıldığını söylerlerse, muhtemelen onların hatalı olduklarını öneririm.