Gesloten . Deze vraag moet meer gefocust zijn. Het accepteert momenteel geen antwoorden.

Opmerkingen

  • Gelinkte vraag is verwijderd.
  • Ik denk dat de aanpak eigenlijk eenvoudig is. Als je het alleen hebt ontwikkeld, weet je er alles van. U kunt de bug zelfs oplossen zonder te debuggen. Met dat in gedachten is de beste manier om je tijd te gebruiken om iets anders te coderen, totdat iemand die er veel van af weet je vraag kan beantwoorden over hoe je het kunt oplossen; of, laat het rusten, codeer andere dingen, totdat een idee om het te repareren in je opkomt, zodat je geen tijd of energie verliest. Mijn gok is dat uw vraag over enterprise team management gaat.
  • Ik denk dat Raid. Kant-en-klare insectenspray. Is dit een filosofische vraag? Boeken worden gemaakt door louter het overwicht …

Antwoord

De mindset en houding ten opzichte van debuggen is misschien wel de het belangrijkste onderdeel, omdat het bepaalt hoe effectief u de fout herstelt, en wat u ervan leert – als er iets is.

Klassiekers over softwareontwikkeling zoals The Pragmatic Programmer en Code Complete pleiten in principe voor dezelfde aanpak: elke fout is een kans om te leren, bijna altijd over jezelf (omdat alleen beginners eerst de compiler / computer de schuld geven).

Behandel het dus als een mysterie dat interessant zal zijn om te kraken. En dat mysterie moet systematisch worden gekraakt, door onze aannames te uiten (aan onszelf of aan anderen) en vervolgens onze aannames te testen, zo nodig één voor één – met behulp van elk hulpmiddel dat we tot onze beschikking hebben, met name debuggers en geautomatiseerde testkaders. Nadat het mysterie is opgelost, kunt u het nog beter doen door al uw code te doorzoeken op soortgelijke fouten die u heeft gemaakt; en schrijf een geautomatiseerde test om ervoor te zorgen dat de fout niet onbewust opnieuw optreedt.

Een laatste opmerking – ik noem fouten liever “fouten” en niet “bugs” – Dijkstra berispte zijn collegas voor het gebruik van de laatste term omdat het is oneerlijk en ondersteunt het idee dat schadelijke en wispelturige bug-feeën bugs in onze programmas plantten terwijl we niet keken, in plaats van daar te zijn vanwege ons eigen (slordige) denken: http://www.cs.utexas.edu/users/EWD/transcriptions/EWD10xx/EWD1036.html

We kunnen bijvoorbeeld beginnen met het opschonen van onze taal door niet langer een bug een bug noemen, maar het een fout noemen. Het is veel eerlijker omdat het de schuld ronduit legt waar het thuishoort, namelijk. met de programmeur die de fout heeft gemaakt. De animistische metafoor van de bug die kwaadwillig naar binnen sloop terwijl de programmeur niet keek, is intellectueel oneerlijk omdat het verhult dat de fout de eigen creatie van de programmeur is. Het aardige van deze simpele verandering van woordenschat is dat het zon diepgaand effect heeft : terwijl voorheen een programma met slechts één bug “bijna correct” was, is een programma met een fout daarna gewoon “fout” (omdat het fout is).

Reacties

  • Eigenlijk vind ik de term " error " in plaats van " bug ", niet omdat het de schuld bij " de programmeur legt die de fout heeft gemaakt ", maar omdat het duidelijk maakt dat het niet de fout van de programmeur kan zijn geweest. Voor mij " bug " impliceert een fout in de code; terwijl " erro r " impliceert een fout ergens . Misschien in de code, misschien in de omgevingsinstellingen, misschien in de vereisten. Maakt me gek als mijn baas een " buglijst " heeft waar de helft van de problemen veranderingen in vereisten zijn. Noem het een takenlijst, ferchrissakes!
  • +1 voor " elke fout is een kans om te leren, bijna altijd over jezelf (omdat alleen beginners de compiler / computer eerst) "
  • U kent de geschiedenis van de term " bug ", toch? Ik bedoel, zoals gebruikt bij softwareontwikkeling. Natuurlijk hebben we ' dit probleem vandaag niet, maar een bug vloog in feite in de hardware van een computer, onopgemerkt door de programmeur, en veroorzaakte een probleem.Tenzij iemand denkt mij te corrigeren, weet ik dat Edison deze term al lang voor het mottenincident gebruikte. Daarom gebruikte ik het woord ' history ', niet ' oorsprong '. Zie computerworld.com/article/2515435/app-development/… en en.wikipedia.org/wiki/Software_bug#Etymology
  • @threed Natuurlijk. Maar al geruime tijd hebben insecten niet de meeste softwarefouten veroorzaakt.

Answer

  1. Schrijf tests. Testen is niet alleen geweldig om bugs te voorkomen (naar mijn ervaring elimineert TDD goed gedaan bijna alle triviale, domme bugs), maar helpt het ook veel bij het opsporen van fouten. Testen dwingt uw ontwerp om tamelijk modulair te zijn, wat het isoleren en repliceren van het probleem een stuk eenvoudiger maakt. Bovendien beheer je de omgeving, waardoor je veel minder voor verrassingen komt te staan. Bovendien, als je eenmaal een falende testcase hebt gekregen, kun je er redelijk zeker van zijn dat je de echte reden van het gedrag dat je dwars zit, hebt genageld.

  2. Leer hoe u een debugger gebruikt. print statements kunnen op een bepaald niveau redelijk goed werken, maar een debugger is meestal zeer nuttig (en een keer je weet hoe je het moet gebruiken, het is veel comfortabeler dan print verklaringen).

  3. Praat over iemand over je probleem, zelfs als het maar een rubberen eendje is. Jezelf dwingen het probleem waaraan je werkt in woorden uit te drukken, doet echt wonderen.

  4. Geef jezelf een tijdslimiet. Als je bijvoorbeeld na 45 minuten het gevoel hebt nergens heen te gaan, schakel dan een tijdje over naar andere taken. Wanneer je terugkeert naar je bug, zul je hopelijk andere mogelijke oplossingen zien die je niet eerder had overwogen.

Opmerkingen

  • +1 voor " Jezelf dwingen het probleem waaraan je werkt in woorden uit te drukken, doet echt wonderen. "
  • En om toe te voegen aan (1), bijna elke bug die je in de code ziet, impliceert dat er ' een bug is – of op zijn minst een weglating – in de testsuite. Los beide tegelijkertijd op en bewijst niet alleen dat u ' het probleem heeft opgelost, u ' bent ertegen opnieuw geïntroduceerd.

Antwoord

Ik vind de meeste andere antwoorden leuk, maar hier zijn enkele tips over wat te doen VOORDAT u dat doet. Bespaart u veel tijd.

  1. Bepaal of er echt een bug is. Een bug is ALTIJD een verschil tussen systeemgedrag en vereisten; de tester moet verwacht en feitelijk gedrag kunnen verwoorden. Als hij geen ondersteuning kan bieden voor het verwachte gedrag, is er geen vereiste en is er geen bug – alleen iemands mening. Stuur het terug.

  2. Overweeg de mogelijkheid dat het verwachte gedrag verkeerd is. Dit kan te wijten zijn aan een verkeerde interpretatie van de vereiste. Het kan ook te wijten zijn aan een defect in de vereiste zelf (een verschil tussen een gedetailleerde vereiste en een zakelijke vereiste). U kunt deze ook terugsturen.

  3. Isoleer het probleem. Alleen ervaring leert je de snelste manier om dit te doen – sommige mensen kunnen het bijna met hun buik doen. Een basisaanpak is om één ding te variëren alle andere dingen constant houden (doet het probleem zich voor in andere omgevingen? met andere browsers? in een andere testregio? op verschillende tijdstippen van de dag?) Een andere benadering is om te kijken naar stackdumps of foutmeldingen – soms zie je het gewoon het is trouwens opgemaakt welk onderdeel van het systeem de oorspronkelijke fout heeft veroorzaakt (bijv. als het in het Duits is, kun je mij die derde partij waarmee je samenwerkt in Berlijn).

  4. Als je het hebt beperkt tot twee systemen die samenwerken, inspecteer dan de berichten tussen de twee systemen via verkeersmonitor of logbestanden , en bepaal welk systeem zich gedraagt volgens de specificaties en welk niet. Als er meer dan twee systemen in het scenario zijn, kunt u paarsgewijze controles uitvoeren en naar beneden werken in de applicatiestapel.

  5. De reden waarom het isoleren van het probleem zo cruciaal is is dat het probleem niet te wijten mag zijn aan een defect in de code waarover u controle heeft (bijvoorbeeld systemen van derden of de omgeving) en u wilt dat die partij het zo snel mogelijk overneemt. Dit is zowel om u werk te besparen als om ze onmiddellijk op het juiste punt te krijgen, zodat de oplossing in een zo kort mogelijk tijdsbestek kan worden bereikt. Je wilt tien dagen lang niet aan een probleem werken om erachter te komen dat het echt een probleem is met de webservice van iemand anders.

  6. Als je hebt vastgesteld dat er echt een defect is en het zit echt in de code die je beheert, kun je het probleem verder isoleren door te zoeken naar de laatste “bekende goede” build en het inspecteren van broncontrolelogboeken op wijzigingen die het probleem mogelijk hebben veroorzaakt. Dit kan veel tijd besparen.

  7. Als u het niet kunt achterhalen via bronbeheer, is dit het moment om uw debugger aan te sluiten en de code te doorlopen om het te achterhalen De kans is groot dat je ondertussen toch een redelijk goed idee hebt van het probleem.

Als je eenmaal weet waar de bug zit en een oplossing kunt bedenken, is hier een goede procedure om het probleem op te lossen:

  1. Schrijf een unit-test die het probleem reproduceert en mislukt.

  2. Maak zonder de unit-test te wijzigen het slaagt (door de applicatiecode te wijzigen).

  3. Bewaar de unit-test in uw testsuite om regressie te voorkomen / detecteren.

Answer

Ik denk dat de reproductie van een bug ook belangrijk is. Alle gevallen die de bug reproduceren, kunnen worden vermeld en vervolgens kunt u ervoor zorgen dat uw bugfix al deze gevallen dekt.

Antwoord

Er is een uitstekend boek dat ik over dit onderwerp heb gelezen met de naam Why Programs Fail , waarin verschillende strategieën worden beschreven voor het vinden van bugs, variërend van het toepassen van de wetenschappelijke methode tot het isoleren en oplossen van een bug, om foutopsporing te voorkomen. Het andere interessante deel van dit boek is dat het de term “bug” wegneemt. De benadering van Zeller is:

(1) Een programmeur creëert een defect in de code. (2) Het defect veroorzaakt een infectie (3) De infectie plant zich voort (4) De infectie veroorzaakt een storing.

Als je je foutopsporingsvaardigheden wilt verbeteren, raad ik dit boek ten zeerste aan.

In mijn eigen persoonlijke ervaring heb ik “veel bugs in onze applicatie gevonden, maar het management drukt ons gewoon verder om nieuwe functies uit te brengen. Ik heb “vaak gehoord”. We hebben deze bug zelf gevonden en de klant heeft hem “nog niet opgemerkt, dus laat hem gewoon staan totdat hij het doet”. Ik denk dat reactief zijn in plaats van proactief te zijn bij het oplossen van bugs een heel slecht idee is, want als het tijd is om daadwerkelijk een fix in te voeren, heb je andere problemen die moeten worden opgelost en wil meer beheer van functies zo snel mogelijk de deur uit, dus je wordt betrapt in een vicieuze cirkel die kan leiden tot veel stress en burn-out en uiteindelijk tot een defect gereden systeem.

Communicatie is ook een andere factor wanneer bugs worden gevonden. Een e-mail verzenden of documenteren op de bug tracker is allemaal goed en wel, maar in mijn eigen ervaring vinden andere ontwikkelaars een vergelijkbare bug en in plaats van de oplossing die je hebt gebruikt om de code te repareren opnieuw te gebruiken (omdat ze het helemaal vergeten zijn), voegen ze hun eigen versies toe, dus je hebt 5 verschillende oplossingen in je code en het ziet er daardoor meer opgeblazen en verwarrend uit. Dus als je een bug oplost, zorg er dan voor dat een paar mensen de oplossing doornemen en je feedback geven voor het geval ze iets soortgelijks hebben opgelost en vond een goede strategie om ermee om te gaan.

limist noemde het boek,

The Pragmatic Programmer die interessant materiaal heeft over het oplossen van bugs. Met behulp van het voorbeeld dat ik in de vorige paragraaf gaf, zou ik dit “bekijken: Software Entrophy , waar de analogie van een gebroken weduwe wordt gebruikt. Als er twee veel gebroken zijn vensters verschijnen, kan uw team apathisch worden om het ooit te repareren, tenzij u een proactieve houding aanneemt.

Opmerkingen

  • I ' heb gehoord " We hebben deze bug zelf gevonden en de client heeft het nog niet ' opgemerkt, dus laat het gewoon staan tot ze doen " ook te vaak. En na sitebezoeken te hebben bezocht, heeft de klant het vaak het opgemerkt, maar ' heeft het niet gemeld. Soms omdat ze denken dat het ' geen zin heeft omdat het ' niet kan worden opgelost, soms omdat ze kijken al naar de vervanging van een concurrent ' en soms (terecht of ten onrechte) " nou, het is is sowieso al een dampende hoop onzin ".
  • @JuliaHayward – Dit is heel vaak het geval, maar in jouw situatie uw klanten kunnen tevreden zijn met de functionaliteit en zich niet al te veel zorgen maken over wat er onder de motorkap gaande is '. Het probleem begint naar boven te komen wanneer de klant terugkomt en om extra functies vraagt en je nog een verbetering moet toevoegen, zoals het meertalig maken van je app, mobiel compliant, bla bla, je begint te kijken naar wat je hebt en ziet alle scheuren in de muur.
  • Laat zien dat alle boeken ter wereld over softwareontwerp, testen en goede communicatie en veel van de producten waaraan je werkt een enorme puinhoop zijn.Ondanks dat je weet wat ' klopt, zijn stress en onrealistische deadlines (in het gezicht van je reeds verknoeide code) de redenen waarom de code in de staat verkeert. Ik heb ' zelf geen antwoorden, ik ' ben behoorlijk gedistingeerd op kantoor als een kreunend gezicht ***** * terwijl ik schop en schreeuw om de code gezond te houden en het ontwikkelingsproces soepel te houden, maar soms hecht het team niet ' goed aan elkaar.

Antwoord

Bug, fout, probleem, defect – hoe je het ook wilt noemen, het maakt niet veel uit. Ik blijf sindsdien bij het probleem “is wat ik gewend ben.

  1. Zoek uit wat de perceptie van het probleem is: vertaal van de” Bob is nog steeds niet in het systeem “van een klant naar” Wanneer ik probeer maak een gebruikersrecord voor Bob, het mislukt met een dubbele sleuteluitzondering, hoewel Bob “er niet al in staat”
  2. Zoek uit of het “echt een probleem is of gewoon een misverstand (inderdaad, Bob is niet” daarbinnen is er niemand die bob heet, en insert zou moeten werken).
  3. Probeer zo min mogelijk betrouwbare stappen te nemen die je kunt volgen om het probleem te reproduceren – zoiets als “Gegeven een systeem met een gebruikersrecord” Bruce “, wanneer een gebruikersrecord” Bob “wordt ingevoegd, treedt er een uitzondering op”
  4. Dit is uw test – plaats deze indien mogelijk in een geautomatiseerde test harnas dat u keer op keer kunt uitvoeren, dit zal van onschatbare waarde zijn bij het debuggen. U kunt het ook onderdeel maken van uw testsuite om ervoor te zorgen dat dat specifieke probleem later niet opnieuw verschijnt.
  5. Haal uw debugger tevoorschijn en begin met het plaatsen van breekpunten – zoek het codepad uit wanneer u uw test uitvoert, en identificeer wat er mis is. Terwijl u dat doet, kunt u uw test ook verfijnen door deze zo smal mogelijk te maken – idealiter een unit-test.
  6. Los het op – controleer of uw test is geslaagd.
  7. Controleer het oorspronkelijke probleem zoals beschreven door de klant is ook opgelost (erg belangrijk – misschien heb je zojuist een subset van het probleem opgelost). Controleer of u geen regressies heeft geïntroduceerd in andere aspecten van het programma.

Als u de code goed kent, of als het probleem of de oplossing duidelijk is, kunt u enkele van deze overslaan stappen.

Hoe moeten we het benaderen om het meest effectief gebruik te maken van onze kostbare tijd en ons in staat te stellen minder tijd te besteden aan het zoeken naar het en meer tijd aan coderen ?

Ik heb daar moeite mee, aangezien het impliceert dat het schrijven van nieuwe code waardevol is dan het hebben van een werkprogramma van hoge kwaliteit. Er is niets mis mee om zo effectief mogelijk te zijn in het oplossen van problemen, maar een programma “wordt niet noodzakelijkerwijs beter door er gewoon meer code aan toe te voegen.

Opmerkingen

  • dit is het beste antwoord IMO

Antwoord

Hier is hoe ik het doe:

  1. gebruik elke keer dezelfde methode om het probleem te vinden. Dit zal uw reactietijd op de fouten verbeteren.
  2. De beste manier is waarschijnlijk om de code te lezen. Dit komt omdat alle informatie beschikbaar is in de code. Je hebt alleen efficiënte manieren nodig om de juiste positie te vinden en het vermogen om alle details te begrijpen.
  3. debuggen is erg traag, en alleen nodig als je programmeurs nog niet begrijpen hoe de computer asm-instructies uitvoert / call-stacks niet kan begrijpen en basiszaken
  4. Probeer bewijstechnieken te ontwikkelen, zoals het gebruik van functieprototypes om te redeneren over het gedrag van het programma. Dit zal helpen om de juiste positie sneller te vinden.

Antwoord

Als we een fout in onze code ontdekken, wat kunnen we dan doen om deze te verwijderen? Hoe moeten we het benaderen om zo effectief mogelijk gebruik te maken van onze kostbare tijd en ons in staat te stellen minder tijd te besteden aan het vinden ervan en meer tijd aan codering? Wat moeten we ook vermijden bij het debuggen?

Ervan uitgaande dat u zich in een productieomgeving bevindt, moet u het volgende doen:

  1. Beschrijf de “fout” correct en identificeer de gebeurtenissen die ervoor zorgen dat deze gebeurt.

  2. Bepaal of de “fout” een codefout is of specificatiefout. Het invoeren van een 1-letterige naam kan voor sommige systemen als een fout worden beschouwd, maar voor andere systemen als acceptabel gedrag. Soms rapporteerde een gebruiker een fout waarvan hij / zij denkt dat het een probleem is, maar de verwachting van de gebruiker voor het gedrag van het systeem maakte geen deel uit van de vereisten.

  3. Als u hebben bewezen dat er een fout zit en de fout te wijten is aan de code, dan kun je bepalen welke codestukken moeten worden gerepareerd om de fout te voorkomen. Onderzoek ook het effect van het gedrag op huidige data en toekomstige systeembewerkingen (impactanalyse op code en gegevens).

  4. Op dit punt zou u waarschijnlijk een schatting hebben van hoeveel bronnen er zullen worden verbruikt om de bug op te lossen. U kunt deze meteen oplossen of plan een oplossing in een aanstaande release van de software.Dit hangt ook af van de vraag of de eindgebruiker bereid is te betalen voor de oplossing. U moet ook verschillende beschikbare opties evalueren om de fout op te lossen. Er kan meer dan één manier zijn. U moet de aanpak selecteren die het beste bij de situatie past.

  5. Analyseer de redenen waarom deze bug verscheen (vereisten, codering, testen, enz.). Dwing processen af die voorkomen dat de toestand zich opnieuw voordoet.

  6. Documenteer de aflevering adequaat.

  7. Geef de fix (of de nieuwe versie)

Geef een reactie

Het e-mailadres wordt niet gepubliceerd. Vereiste velden zijn gemarkeerd met *