IDE'de hata ayıklama neden daha iyidir? [kapalı]

Yirmi yılı aşkın süredir C, Perl, SQL, Java, PHP, JavaScript ve yakın zamanda Python'da programlama yapan bir yazılım geliştiricisiyim. Hiç bir zaman sorun yaşamadım, bazı dikkatli düşünceler ve iyi yerleştirilmiş hata ayıklama printifadeleri kullanarak hata ayıklayamadım .

Birçok insanın tekniklerimin ilkel olduğunu ve bir IDE'de gerçek bir hata ayıklayıcı kullanmanın çok daha iyi olduğunu söylemesine saygı duyuyorum. Yine de benim gözlemime göre, IDE kullanıcıları benim taş bıçaklarımı ve ayı postlarımı kullanarak benden daha hızlı veya daha başarılı bir şekilde hata ayıklamıyor gibi görünüyor. Doğru araçları öğrenmeye içtenlikle açığım, görsel hata ayıklayıcıları kullanmak konusunda hiçbir zaman ikna edici bir avantaj görmedim.

Dahası, kesme noktalarının nasıl ayarlanacağına ve değişkenlerin içeriklerinin nasıl görüntüleneceğine ilişkin temellerin ötesinde, bir IDE kullanarak etkin bir şekilde nasıl hata ayıklanacağını gösteren bir öğretici veya kitabı hiç okumadım.

Neyi kaçırıyorum? IDE hata ayıklama araçlarını, teşhis printifadelerinin dikkatli kullanımından çok daha etkili kılan nedir ?

IDE hata ayıklamanın daha ince tekniklerini gösteren kaynaklar (eğitimler, kitaplar, ekran kayıtları) önerebilir misiniz?

Tatlı cevaplar! Zaman ayırdığınız için herkese çok teşekkürler. Çok aydınlatıcı. Birçoğuna oy verdim ve hiçbirini reddettim.

Bazı önemli noktalar:

• Hata ayıklayıcılar, değişkenlerin, kodun veya çalışma zamanı ortamının herhangi bir yönünün geçici olarak incelenmesine veya değiştirilmesine yardımcı olabilir , oysa manuel hata ayıklama, uygulamayı durdurmamı, düzenlememi ve yeniden çalıştırmamı gerektirir (muhtemelen yeniden derlemeyi gerektirir).
• Hata ayıklayıcılar çalışan bir işleme ekleyebilir veya bir kilitlenme dökümü kullanabilir, oysa manuel hata ayıklamada bir hatayı "yeniden oluşturma adımları" gereklidir.
• Hata ayıklayıcılar, karmaşık veri yapılarını, çok iş parçacıklı ortamları veya tam çalışma zamanı yığınlarını kolayca ve daha okunaklı bir şekilde görüntüleyebilir.
• Hata ayıklayıcılar, neredeyse tüm hata ayıklama görevlerini yapmak için zamanı ve tekrar eden işi azaltmak için birçok yol sunar.
• Görsel hata ayıklayıcılar ve konsol hata ayıklayıcıları hem faydalıdır hem de birçok ortak özelliğe sahiptir.
• Bir IDE'ye entegre edilmiş görsel bir hata ayıklayıcı ayrıca, tek bir entegre geliştirme ortamında (dolayısıyla adı) akıllı düzenlemeye ve IDE'nin diğer tüm özelliklerine kolay erişim sağlar.

Bir IDE hata ayıklayıcısının size kodda izleme mesajları vereceği bazı yeteneklere örnekler:

• Mevcut yığın çerçeveniz için bir bağlam sağlayarak , çağrı yığınını istediğiniz zaman görüntüleyin.
• İz ekleme amacıyla yeniden derleyemediğiniz kitaplıklara adım atın (hata ayıklama sembollerine erişiminiz olduğunu varsayarak)
• Program çalışırken değişken değerleri değiştirin
• Düzenle ve devam et - çalışırken kodu değiştirme ve değişikliğin sonuçlarını anında görme yeteneği
• Muktedir izlemek onlar değiştirdiğinizde görerek, değişkenleri
• Muktedir atlamak veya kod bölümlerini tekrarlamak kod nasıl performans göstereceğini görmek. Bu, teorik değişiklikleri yapmadan önce test etmenizi sağlar.
• Bellek içeriklerini gerçek zamanlı olarak inceleyin
• Uygulama tarafından ele alınsalar bile belirli istisnalar oluştuğunda sizi uyarır.
• Koşullu kesme noktası oluşturma ; Yığını ve değişkenleri analiz etmenize izin vermek için uygulamayı yalnızca istisnai durumlarda durdurma.
• İzlemeyle elde edilmesi zor olabilen çok iş parçacıklı uygulamalarda iş parçacığı bağlamını görüntüleyin (farklı iş parçacıklarından izler çıktıda araya ekleneceğinden).

Özetle, baskı ifadeleri (genellikle) statiktir ve orijinal ifadeleriniz yeterince ayrıntılı değilse ek bilgi almak için yeniden derlemeniz gerekir. IDE, bu statik engeli ortadan kaldırarak size parmaklarınızın ucunda dinamik bir araç seti sunar.

Kodlamaya ilk başladığımda, hata ayıklayıcılarla ilgili önemli şeyin ne olduğunu anlayamadım ve izleme ile her şeyi başarabileceğimi düşündüm (verilmiş, bu unix'te ve hata ayıklayıcı GDB'ydi). Ancak bir grafik hata ayıklayıcısını doğru bir şekilde kullanmayı öğrendikten sonra, ifadeleri yazdırmaya geri dönmek istemezsiniz.

• IDE hata ayıklayıcı, çalışma zamanında değişkenlerin değerlerini değiştirmenize olanak tanır.

• Bir IDE hata ayıklayıcı, yürütmenin ne zaman başladığını görmek istediğinizi bilmediğiniz değişkenlerin değerini görmenizi sağlar.

• Bir IDE hata ayıklayıcı, çağrı yığınını görmenize ve tuhaf değerler geçirilen işlevin durumunu incelemenize olanak tanır. (bu işlevin yüzlerce yerden çağrıldığını düşünün, bu tuhaf değerlerin nereden geldiğini bilmiyorsunuz)

• Bir IDE hata ayıklayıcı, kodun herhangi bir noktasında, satır numarasına değil bir koşula göre yürütmeyi koşullu olarak kesmenize olanak tanır.

• Bir IDE hata ayıklayıcı, işlenmemiş bir istisna olması durumunda sadece sıçmak yerine programın durumunu incelemenizi sağlar.

İşte "yazdırma" ifadesiyle kesinlikle hata ayıklayamayacağınız bir şey var; bir müşteri size bellek dökümü getirip "programınız çöktü, nedenini bana söyleyebilir misiniz?"

• Tüm kodunuz boyunca ifadeleri yazdırın okunabilirliği azaltır.
• Bunları yalnızca hata ayıklama amacıyla eklemek ve kaldırmak zaman alıcıdır
• Hata ayıklayıcılar çağrı yığınını izleyerek nerede olduğunuzu görmeyi kolaylaştırır
• Değişkenler anında değiştirilebilir
• Adhoc komutları, tanılamaya yardımcı olmak için yürütme sırasında bir duraklama sırasında yürütülebilir
• BİRLİKTE, yazdırma deyimleriyle kullanılabilir: Debug.Write ("...")

Bence baskı ifadelerini kullanarak hata ayıklamanın kayıp bir sanat olduğunu ve her geliştiricinin öğrenmesi için çok önemli olduğunu düşünüyorum. Bunu nasıl yapacağınızı öğrendikten sonra, belirli hata sınıflarının bu şekilde hata ayıklaması bir IDE'den çok daha kolay hale gelir. Bu tekniği bilen programcılar, hata ayıklama amacı taşımayan amaçlar için de bir günlük mesajı (aslında günlüğü okuyacağınızdan bahsetmiyorum) koymak için yararlı bilgilerin neler olduğuna dair gerçekten iyi bir hisse sahiptir.

Bununla birlikte, adım adım hata ayıklayıcıyı nasıl kullanacağınızı gerçekten bilmelisiniz, çünkü farklı bir hata sınıfı için ÇOK daha kolaydır. Nedenini açıklamak için bunu daha önce yayınlanmış diğer mükemmel cevaplara bırakacağım :)

Kafamın üstünden:

1. Karmaşık nesnelerde hata ayıklama - Hata ayıklayıcılar, bir nesnenin iç kısımlarının derinliklerine adım atmanıza olanak tanır. Örneğin, nesnenizde bir dizi karmaşık nesne varsa, yazdırma ifadeleri sizi yalnızca bir yere kadar götürür.
2. Geçmiş kodu adım atma yeteneği - Hata ayıklayıcılar, yürütmek istemediğiniz geçmiş kodu atlamanıza da izin verir. Doğru, bunu manuel olarak da yapabilirsiniz, ancak enjekte etmeniz gereken çok daha fazla koddur.

IDE'de hata ayıklamaya alternatif olarak , php kitaplığına sahip harika Google Chrome uzantısı PHP Konsolu'nu deneyebilirsiniz :

• Chrome JavaScript konsolunda ve bildirim açılır pencerelerinde hataları ve istisnaları görün.
• Herhangi bir tür değişkeni boşaltın.
• PHP kodunu uzaktan çalıştırın.
• Erişimi parolayla koruyun.
• Konsol günlüklerini isteğe göre gruplandırın.
• Metin düzenleyicinizdeki hata dosyası: satırına gidin.
• Hata / hata ayıklama verilerini panoya kopyala (test kullanıcıları için).

Yaklaşık 20 yıldır geliştirme yapmıyorum, ancak bir IDE / hata ayıklayıcı kullanarak şunları yapabileceğimi görüyorum:

• bir basılı ifadeye dahil etmeyi düşünmemiş olabileceğim her türlü şeyi görün
• kodun, izleyeceğini düşündüğüm yolla eşleşip eşleşmediğini görmek için adım adım
• Kodun belirli dalları almasını sağlamak için değişkenleri belirli değerlere ayarlayın

IDE'yi kullanmanın bir nedeni, modern IDE'lerin basit kesme noktalarından daha fazlasını desteklemesi olabilir. Örneğin, Visual Studio aşağıdaki gelişmiş hata ayıklama özelliklerini sunar:

• koşullu kesme noktaları tanımlayın (yalnızca bir koşul karşılandığında veya yalnızca kesme noktasındaki ifade çalıştırıldığında n'inci sırada kesilir)
• işlenmemiş bir istisnayı kırmak veya (belirli) bir ekxeption fırlatıldığında
• hata ayıklama sırasında değişkeni değiştir
• yürütülecek bir sonraki satırı ayarlayarak bir kod parçasını tekrarlamak
• vb.

Ayrıca, hata ayıklayıcıyı kullanırken, hata ayıklamayı bitirdikten sonra tüm yazdırma ifadelerinizi kaldırmanız gerekmez.

Başka bir cevapta görmediğime şaşırdığım bir şey, 2 hata ayıklama yönteminin birbirini dışlamamasıdır .

printfStandart bir hata ayıklayıcı kullanıyor olsanız bile (IDE tabanlı olsun ya da olmasın) hata ayıklama oldukça iyi çalışabilir. Özellikle bir günlüğe kaydetme çerçevesi sayesinde, müşteri sorunlarını teşhis etmeye yardımcı olmak için piyasaya sürülen ürünün tamamını veya çoğunu bırakabilirsiniz.

Buradaki diğer yanıtların hemen hemen hepsinde belirtildiği gibi, standart bir hata ayıklayıcının en güzel yanı, program durumunun ayrıntılarını daha kolay incelemenize (ve potansiyel olarak değiştirmenize) olanak vermesidir. Neye bakmak isteyebileceğinizi önceden bilmek zorunda değilsiniz - hepsi parmaklarınızın ucunda (az ya da çok).

Deneyimlerime göre, basit çıktıların kimsenin bahsetmediği büyük bir avantajı var.

Bir IDE hata ayıklayıcısındaki sorun, her şeyin gerçek zamanlı gerçekleşmesidir. Programı belirli bir zamanda durduruyorsunuz, ardından adım adım adım adım ilerliyorsunuz ve daha önce ne olduğunu aniden görmek istiyorsanız geri dönmeniz imkansız. Bu, beynimizin nasıl çalıştığıyla tamamen çelişiyor. Beyin bilgi toplar ve yavaş yavaş bir görüş oluşturur. Bunu yaparken olayları birkaç kez yinelemek gerekebilir, ancak belirli bir noktayı geçtikten sonra geri dönemezsiniz.

Bunun aksine, seçilen bir dizi çıktı / kayıt, size "zamansal olayların uzamsal projeksiyonunu" verir. Size neler olduğuna dair eksiksiz bir hikaye sunar ve sadece yukarı ve aşağı kaydırarak birkaç kez çok kolay bir şekilde geri ve dördüncü dönebilirsiniz. "A, B olmadan önce mi oldu" gibi sorulara cevap vermeyi kolaylaştırır. Aramak bile istemediğiniz kalıpları görmenizi sağlayabilir.

Benim deneyimime göre. IDE ve hata ayıklayıcılar, tek bir çağrı yığınındaki bir şey ters gittiğinde basit sorunları çözmek ve belirli bir çökme anında makinenin mevcut durumunu keşfetmek için harika araçlardır.

Bununla birlikte, kademeli durum değişiminin söz konusu olduğu daha karmaşık problemlere yaklaştığımızda. Örneğin bir algoritma bir veri yapısını bozduğunda, bu da daha sonra bir algoritmanın başarısız olmasına neden oldu. Ya da "bu ne sıklıkla olur" gibi sorulara cevap vermek istiyorsak, "işler sırayla ve olmasını hayal ettiğim şekilde gerçekleşir". vb. O halde "eski moda" kayıt / çıktı alma tekniğinin açık bir avantajı vardır.

En iyisi, her iki tekniği de en uygun olduğunda kullanmaktır; örneğin, bazı hatalara ulaşmak için günlük kaydı / çıktı kullanmak ve mevcut durumu daha ayrıntılı olarak keşfetmemiz gereken bir kesme noktasında duraklamak.

Hibrit yaklaşımlar da var. Örneğin, console.log (nesne) yaptığınızda, günlükte daha ayrıntılı olarak genişletebileceğiniz ve keşfedebileceğiniz bir veri yapısı widget'ı alırsınız. Bu, çoğu zaman "ölü" bir metin günlüğüne göre açık bir avantajdır.

Çünkü yazdırma deyimleriyle çok iş parçacıklı uygulamalarda hata ayıklamak sizi muzdarip edecektir. Evet, bunu yine de baskı ifadeleriyle yapabilirsiniz, ancak bunların çoğuna ihtiyacınız olacak ve çok iş parçacıklı yürütmeyi taklit etmek için ifadelerin sıralı çıktılarının çözülmesi uzun zaman alacaktır.

İnsan beyni maalesef sadece tek ipliklidir.

Kitaplara işaret etmek istediğinizden beri ... Windows hata ayıklamaya gelince, John Robbins, Windows hata ayıklama üzerine iyi bir kitabın birkaç basımına sahiptir:

Microsoft .NET ve Microsoft Windows için Uygulamalarda Hata Ayıklama

En son sürümün ( Microsoft .NET 2.0 Uygulamalarında Hata Ayıklama ) yalnızca .NET olduğunu unutmayın, bu nedenle yerel kod hata ayıklamasını istiyorsanız (hem .NET hem de yerel'i kapsar) daha eski bir sürümü ( ilk bağlantıdaki gibi) isteyebilirsiniz.

Ben şahsen cevabın "Entegre bir hata ayıklayıcı / IDE komutları girmeye gerek kalmadan size çok sayıda farklı bilgiyi hızlı bir şekilde verir. Bilgi, siz ne yapacağınızı söylemeden önünüzde olma eğilimindedir. göstereceğim.

Kolaylığı bilgi alınabilir hangi sadece komut satırı hata ayıklama veya "printf" ayıklama daha iyi hale getiren, bu.

Bir hata ayıklayıcının printf üzerindeki avantajları ( bir IDE hata ayıklayıcısına değil, herhangi bir hata ayıklayıcısına dikkat edin )

1. İzleme noktaları belirleyebilir. Bu, hafıza bozulmalarını bulmanın en sevdiğim yollarından biri

2. Şu anda yeniden derleyemeyeceğiniz bir ikili dosyanın hatalarını ayıklayabilir

3. Yeniden derlenmesi uzun süren bir ikili dosyanın hatalarını ayıklayabilir

4. Değişkenleri anında değiştirebilir

5. Fonksiyonları anında çağırabilir

6. Hata ayıklama durumlarının temizlenmediği ve bu nedenle zamanlama sorununun hatasız bir şekilde ayıklanamadığı bir sorunu yok

7. Hata ayıklayıcılar temel dökümlere yardımcı olur, baskı ifadeleri

VS.NET hata ayıklama pencerelerinde en çok kullandığım şey bu:

• Çağrı yığını, aynı zamanda başka birinin kodunu anlamanın harika bir yoludur
• Yerliler ve Saatler.
• Temelde bir C # konsolu olan ve ayrıca değişken içerikleri değiştirmeme, malzemeleri başlatmama vb. İzin veren anında pencere.
• Bir satırı atlama yeteneği, sonraki ifadeyi başka bir yerde yürütülecek şekilde ayarlayın.
• Değişkenlerin üzerine gelme ve bana değerlerini gösteren bir araç ipucuna sahip olma yeteneği.

Özetle, bana sadece küçük bir pencere değil, yürütme kodumun durumunun 360 derecelik bir görünümünü veriyor.

Bu tür şeyleri öğreten bir kitap bulamadım ama yine de oldukça basit görünüyor, neredeyse WYSIWYG.

• Bir hata ayıklayıcı, çalışan bir işleme eklenebilir

• Bir hata ayıklayıcıdan iş parçacıklı kodda hata ayıklamak genellikle daha kolaydır

Bir IDE hata ayıklayıcı ile, yürütmeyi her durdurduğunuzda geçerli kapsamdaki TÜM değişkenlerin değerlerini (çağrı yığınının sonuna kadar) görebilirsiniz.

Baskı tablolar harika ama üretebilir herhangi bir yerde ekrana çok fazla bilgi damping olabilir bütün baskı tabloların çok.

Ayrıca, birçok IDE hata ayıklayıcısı, yöntemleri yazmanıza ve değerlendirmenize ve siz durdurulmuşken üyeleri değerlendirmenize izin verir, bu da yapmanız gereken baskı ifadelerinin miktarını daha da artırır.

Hata ayıklayıcıların bazı diller için diğerlerinden daha iyi olduğunu düşünüyorum ancak

Genel görüşüm, IDE hata ayıklayıcılarının Java veya C # gibi yönetilen diller için kesinlikle, inanılmaz derecede harika olduğu, C ++ için oldukça yararlı olduğu ve Python gibi kodlama dilleri için pek kullanışlı olmadığıdır (ancak iyi bir şey denememiş olabilirim) henüz herhangi bir komut dosyası dili için hata ayıklayıcı).

Java geliştirme yaptığımda IntelliJ IDEA'daki hata ayıklayıcıyı kesinlikle seviyorum. Python kullandığımda sadece yazdırma ifadelerini kullanıyorum.

Yukarıda birinin söylediği gibi: Hata Ayıklayıcı! = IDE.

gdb ve (geri dönüş) TurboDebugger (bağımsız) destekledikleri diller için gayet iyi çalışıyor [ed], teşekkür ederim. (veya daha eski bir teknoloji: xBase yürütülebilir dosyasının kendisine bağlı Clipper hata ayıklayıcı) - bunların hiçbiri bir IDE gerektirmedi

Ayrıca, C / ++ kodlaması daha nadir olmasına rağmen, printf ifadeleri bazen bulmaya çalıştığınız hatayı gizler! (örneğin, yığındaki otomatik değişkenlerdeki başlatma sorunları veya bellek ayırma / hizalama)

Son olarak, diğerlerinin de belirttiği gibi, ikisini de kullanabilirsiniz. Bazı gerçek zamanlı sorunlar neredeyse bir baskı veya en azından mantıklı bir "* video_dbg = (is_good? '+': '-');" video belleğinde bir yer. Yaşım gösteriyor, bu DOS'un altındaydı :-)

TMTOWTDI

Diğer posterlerin söylediklerinin çoğuna ek olarak, beni her seferinde bir satır düşünmeye zorladığından, bilgisayarla birlikte her seferinde bir satırdan geçmeyi gerçekten seviyorum. Çoğu zaman, değişken değerlere bakmadan bile hatayı yakalayacağım çünkü 'sonraki satır' düğmesine tıkladığımda ona bakmak zorunda kalıyorum. Yine de cevabımın sana yardımcı olacağını sanmıyorum Bill, çünkü muhtemelen zaten bu beceriye sahipsin.

Öğrenme kaynakları söz konusu olduğunda, hiç kullanmadım - sadece tüm menüleri ve seçenekleri araştırıyorum.

Bu gerçek programcıdan gelen gerçek soru mu?

Basılı ifadelerle hata ayıklamak ve IDE ile hata ayıklamak için 5 dakika bile harcayan herkes - sormadan bile OLACAKTIR!

Hata ayıklama için hem baskıları hem de IDE'leri kullandım ve bir IDE kullanarak hata ayıklamayı tercih ederim. Bunun işe yaramadığı tek zaman, zaman açısından kritik durumlarda (çevrimiçi oyunlarda hata ayıklama gibi) kodu baskı ifadeleriyle doldurduğunuz ve ardından korkunç bir şekilde yanlış gittikten sonra günlük dosyalarına baktığınız zamanlardır. Sonra hala anlayamıyorsanız, daha fazla baskı ekleyin ve tekrarlayın.

Bir IDE'de bir konsol hata ayıklayıcısının printf ve vs hata ayıklayıcının kullanışlı bir özelliğinden bahsetmek istedim.

Uzak bir uygulamaya ekleyebilir (açıkça, DEBUG modunda derlenmiştir) ve POSIX teeyardımcı programını kullanarak hata ayıklayıcı çıktısını bir dosyaya dökerek durumunu inceleyebilirsiniz . Printf ile karşılaştırıldığında, çalışma zamanında durumun nereye çıktılacağını seçebilirsiniz.

Agresif bir ortamda konuşlandırılan Adobe Flash uygulamalarında hata ayıklarken bana çok yardımcı oldu . Her bir kesme noktasında gerekli durumu yazdıran bazı eylemler tanımlamanız, konsol hata ayıklayıcısını başlatmanız fdb | tee output.logve bazı kesme noktalarında gezinmeniz yeterlidir. Bundan sonra günlüğü yazdırabilir ve durumu farklı kesme noktalarında kapsamlı bir şekilde karşılaştırarak bilgileri analiz edebilirsiniz.

Ne yazık ki, bu özellik [bir dosyaya giriş yapma] GUI hata ayıklayıcılarında nadiren bulunur ve geliştiricilerin kafalarındaki nesnelerin durumunu karşılaştırmasını sağlar.

Bu arada, benim fikrim, bir hata ayıklayıcıya bakmadan önce nerede ve neyin hata ayıklanacağını planlaması gerektiğidir.

Başka bir şey de, yeni bir eski projeye katılırsanız ve kimse kodun ne yaptığını gerçekten bilmiyorsa, o zaman değişkenleri / nesneleri / ... yankılayarak hata ayıklayamazsınız. B / c kodun ne olduğu hakkında hiçbir fikriniz olmaz hiç idam edildi.

İşimde tam olarak bu tür bir durumla karşı karşıyayım ve görsel XDebuging, neler olduğu ve nerede olduğu hakkında bir fikir edinmeme yardımcı oluyor.

Saygılarımla

Raffael

Daha önce bahsedilen birçok şeye ek olarak, bir hata ayıklayıcının printf'e göre en önemli avantajlarından biri, printf ifadelerinin kullanılması, hatanın hangi işlevde bulunduğunu bildiğinizi varsaymasıdır. Çoğu durumda yapmazsınız, bu nedenle yerelleştirmek için birkaç tahminde bulunmanız ve diğer birçok işleve yazdırma ifadeleri eklemeniz gerekir. Hata, çerçeve kodunda veya düşündüğünüz yerden çok uzak bir yerde olabilir. Bir hata ayıklayıcıda, kodun farklı alanlarında ve zamanın farklı noktalarında durumu incelemek için kesme noktaları ayarlamak çok daha kolaydır.

Ayrıca, iyi bir hata ayıklayıcı, kesme noktalarına koşullar ve eylemler ekleyerek printf tarzı hata ayıklama yapmanıza izin verir, böylece kodu değiştirmeden, printf hata ayıklamanın avantajlarından yararlanmaya devam edersiniz.

Bir IDE'de hata ayıklama, paylaşılan bir ana bilgisayar gibi hata günlüklerinin ve kabuk erişiminin kullanılamadığı bir ortamda paha biçilmezdir. Bu durumda, uzaktan hata ayıklayıcıya sahip bir IDE, view stderrveya stdout.

Print ifadelerini kullanmanın bir problemi, kodunuzun dağılmasına neden olmasıdır. IE, 10 parçalı bir fonksiyonunuz var ve bunun bir yerde çöktüğünü biliyorsunuz, ancak nerede olduğundan emin değilsiniz. Böylelikle hatanın nerede olduğunu belirlemek için 10 ekstra baskı ifadesi eklersiniz. Hatanızı bulup çözdükten sonra, artık tüm bu yazdırma ifadelerini kaldırarak temizlemeniz gerekir. Belki bunu yaparsın. Belki unutursunuz ve üretimde sona erer ve kullanıcı konsolunuzun hata ayıklama baskılarıyla dolu olur.

Wauw, bu soruyu beğendim mi? Asla poz vermeye cesaret edemedim ...

Görünüşe göre insanların farklı çalışma yöntemleri var. Benim için en iyi olan şudur:

• Bellek yönetimi dahil kodumun sağlam bir zihin modeline sahip olmak
• Olanları takip etmek için enstrümantasyon (basılı ifadeler gibi) kullanma.

Yaşayan programlamayı 40 yıldan fazla bir süredir, günlük C ++ ve Python'da önemsiz olmayan teknik ve bilimsel uygulamalarda çalışarak kazandım ve bir hata ayıklayıcının bana hiç yardımcı olmadığı kişisel deneyime sahibim.

Bunun iyi olduğunu söylemiyorum. Bunun kötü olduğunu söylemiyorum. Sadece paylaşmak istiyorum

Bu sadece hata ayıklama değil. Bir IDE, birçok yoldan daha iyi yazılımı daha hızlı oluşturmanıza yardımcı olur:

• yeniden düzenleme araçları
• API'nin daha keşfedilebilir olmasını sağlamak veya tanıdık öğelerin tam olarak yazımını / durumunu hatırlatmak için intellisense (aynı sistemi 15 yıldır kullandıysanız pek işe yaramaz, ancak bu nadirdir)
• Değişken ve sınıf adlarını otomatik tamamlayarak yazma işleminden tasarruf
• derlemeye başlamadan önce belirli türdeki hataları bulun
• Aynı dosya veya klasörde olmasalar bile otomatik olarak değişken / yöntem / sınıf bildirimlerine / tanımlarına atlayın.
• İşlenmeyen ve ele alınmayan istisnalarda kırılma

Devam edebilirim.