Hoe ga je met tussenpozen bugs benaderen?

Er is niet een antwoord op dit probleem. Soms is de oplossing die u hebt gevonden helpt je erachter te komen het scenario voor het probleem, in welk geval u dat scenario kunt testen voor en na de fix te reproduceren. Soms echter, dat oplossing die u hebt gevonden lost slechts een van de problemen, maar niet allemaal, of als je zegt dat maskers een dieper probleem. Ik wou dat ik kon zeggen: "dit doet, het werkt elke keer", maar er is niet een "dit" dat past bij dat scenario.

Instrument de opbouw met uitgebreidere (eventueel optioneel) logging en data opslaan die exacte weergave van de variabele gebruikersinterface stelt de gebruiker stappen voordat de botsing optrad.

Als de data niet op betrouwbare wijze kunt u het probleem te reproduceren dan heb je de klasse van de bug versmald. Tijd om te kijken naar bronnen van willekeurige gedrag, zoals variaties in de systeemconfiguratie, wijzer vergelijkingen, geïnitialiseerde data, etc.

Soms heb je "weten" (of liever het gevoel) dat u het probleem kunt oplossen zonder uitgebreide testen of unit testing steigers, omdat je echt begrijpen het probleem. Echter, als je dat niet doet, dan komt heel vaak neer op iets als "we liep het 100 keer en de fout niet meer opgetreden, dus we beschouwen het als vast tot de volgende keer dat het wordt gemeld.".

Je zult nooit in staat zijn om de correctie te controleren zonder het identificeren van de oorzaak en het bedenken van een betrouwbare manier om de bug te reproduceren.

Voor het identificeren van de oorzaak: Als uw platform toelaat, haak een aantal post-mortem debugging in het probleem.

Bijvoorbeeld, op Windows, krijg je code om een ​​minidumpdossier (core dump op Unix) te maken wanneer dit een dergelijk probleem tegenkomt. U kunt dan krijgt de klant (of WinQual, op Windows) om u dit bestand te sturen. Dit moet u meer informatie over hoe uw code verkeerd op het productiesysteem is weg te geven.

Maar zonder dat, zult u nog steeds nodig om te komen met een betrouwbare manier om de bug te reproduceren. Anders zul je nooit in staat zijn om te controleren of het is opgelost.

Zelfs met al deze informatie, kun je uiteindelijk de vaststelling van een bug die eruit ziet, maar het is niet, degene die de klant ziet.

Die types van bugs zijn zeer frustrerend. Extrapoleren het uit aan verschillende machines met verschillende soorten aangepaste hardware die mogelijk in hen (zoals bij mijn bedrijf), en oh boy is het een nachtmerrie geworden. Ik heb momenteel een aantal bugs zoals deze op het moment van mijn werk.

Mijn vuistregel: I do not fix it, tenzij ik het kan reproduceren mezelf of ik gepresenteerd met een log waaruit duidelijk blijkt iets mis. Anders kan ik mijn verandering te controleren, noch kan ik controleren of mijn verandering niets anders heeft verbroken. Natuurlijk, het is gewoon een vuistregel - ik maak uitzonderingen.

Ik denk dat je hebt helemaal gelijk om bezorgd te zijn met de aanpak van uw colleuge.

Deze problemen zijn altijd veroorzaakt door:

1. Problemen met het geheugen
2. Threading Problemen

Om het probleem, je moet op te lossen:

• Instrument uw code (Voeg log statements)
• Code Review threading
• Code Review geheugentoewijzing / dereferentie

De code reviews zal waarschijnlijk alleen gebeuren als het een prioriteit is, of als u een sterk vermoeden over welke code wordt gedeeld door de meervoudige bug reports. Als het een threading probleem, controleer dan de draad veiligheid - zorg ervoor dat variabelen toegankelijk door beide draden worden beschermd. Als het een geheugen probleem, controleer dan de toewijzingen en dereferences en in het bijzonder verdacht van de code die toewijst en keert het geheugen, of code die geheugentoewijzing gebruikt door iemand anders die het kan vrijgeven zijn.

Ik gebruik maken van wat ik noem "zware defensief programmeren" : add beweert in alle modules die lijkt met elkaar verbonden door het probleem. Wat ik bedoel is, voegen veel van beweert , beweert bewijzen, beweren status van objecten in al hun memebers, beweren "environnement" staat, enz.

Beweert u helpen om de code die niet is gekoppeld aan het probleem te identificeren.

Het grootste deel van de tijd dat ik op zoek naar de oorsprong van het probleem alleen door het schrijven van de beweringen als het dwingt je om alle code herlezen en plundge onder het lef van de aanvraag om het te begrijpen.

In deze situatie, waar niets anders werkt, introduceer ik extra houtkap.

Ik heb ook te voegen in e-mailberichten die me tonen de status van de toepassing wanneer het afbreekt.

Soms voeg ik in performance counters ... Ik heb die gegevens in een tabel en kijk naar trends.

Zelfs als er niets opduikt, wordt u vernauwing dingen naar beneden. Op een of andere manier, je zult eindigen met bruikbare theorieën.

Eerst moet je stacktraces te krijgen van uw klanten, op die manier kun je eigenlijk een aantal forensisch onderzoek te doen.

Vervolgens doe je fuzz testen met willekeurige input, en houd deze tests lopen voor lange afstanden, ze zijn goed in het vinden van die irrationele grensgevallen, die de menselijke programmeurs en testers door middel van cases en begrip van de code gebruik kan vinden.

Enkele vragen die je zou kunnen afvragen:

• Wanneer deed dit stukje code laatste werk zonder problemen.
• Wat is er gedaan, omdat het gestopt met werken.

Als de code nog nooit heeft gewerkt aan de aanpak zou natuurlijk anders zijn.

Tenminste als veel gebruikers een veel code veranderen de hele tijd is dit een veel voorkomende scenario.

Dit zijn verschrikkelijk en bijna altijd bestand tegen de 'gebrand' de ingenieur denkt dat hij zet in, omdat ze een gewoonte van terug te komen maanden later bijten. Wees op uw hoede van fixes aan intermitterende bugs. Wees voorbereid op een beetje grunt werk en intensieve houtkap dit klinkt meer van een test probleem dan een ontwikkelingsprobleem.

Mijn eigen probleem bij het overwinnen van bugs zoals deze was dat ik vaak te dicht bij het probleem, niet permanent terug en kijken naar het grotere plaatje. Probeer iemand anders te kijken naar hoe je het probleem aan te pakken.

Met name mijn bug was te maken met de instelling van de time-outs en diverse andere magische getallen die achteraf, waar borderline en dus bijna alle van de gewerkte tijd. De truc in mijn geval was het een veel geëxperimenteerd met instellingen die ik kon vinden welke zou 'breken' van de software waarden doen.

Laat de mislukkingen gebeuren tijdens specifieke perioden? Zo ja, waar en wanneer? Is het alleen bepaalde mensen die lijken op de bug te reproduceren? Wat stel ingangen lijken om het probleem uit te nodigen? Welk deel van de applicatie is het niet aan de hand? Heeft de bug min of meer intermitterende uit lijken in het veld?

Toen ik een software tester was mijn belangrijkste instrumenten waarbij een pen en papier om aantekeningen van mijn eerdere acties op te nemen - herinner me een heleboel schijnbaar onbelangrijke details is van vitaal belang. Door het observeren en het verzamelen van kleine stukjes van de gegevens de hele tijd de bug zal verschijnen om minder af en toe wegvallen.

specifieke scenario

Hoewel ik niet wil concentreren op alleen het probleem dat ik heb, hier zijn enkele details van de huidige uitgave waar we voor staan ​​en hoe ik heb het tot nu toe aangepakt.

Het probleem treedt op wanneer de gebruiker met de gebruikersinterface (a TabControl om precies te zijn) in een bepaalde fase van een proces. Het hoeft niet altijd voorkomen en ik denk dat dit komt omdat het raam van tijd voor het probleem dat moet worden tentoongesteld is klein. Ik vermoed dat het initialiseren van een user control (we in .NET met C #) samenvalt met een statusverandering gebeurtenis uit een ander gebied van de toepassing, hetgeen tot een lettertype is aangebracht. Ondertussen ander besturingselement (a label) tracht de reeks putten dat lettertype en dus de crash.

Echter, in feite een bevestiging wat leidt tot het lettertype is aangebracht moeilijk is gebleken. De huidige oplossing is om het lettertype klonen waardoor de tekening label nog steeds geldig lettertype, maar eigenlijk maskeert de wortel probleem dat het lettertype is aangebracht in de eerste plaats. Uiteraard wil ik graag het opsporen van de volledige sequentie, maar dat blijkt zeer moeilijk en de tijd is kort.

Nadering

Mijn aanpak was voor het eerst te kijken naar de stack trace van onze crash rapporten en onderzoeken van de Microsoft-code met behulp van Reflector. Helaas leidde dit tot een GDI + bellen met weinig documentatie, die slechts een nummer is terug voor de fout - .NET dit verandert in een vrij nutteloos bericht dat er iets is ongeldig. Super goed.

Van daaruit ging ik kijken naar wat oproep in onze code leidt tot dit probleem. De stack begint met een bericht lus, niet in onze code, maar ik vond een oproep aan Update () in de algemene ruimte onder verdenking en, met behulp van instrumenten (sporen, etc), waren we in staat om te bevestigen tot ongeveer 75% zekerheid dat deze was de bron van het bericht verf. Het was echter niet de bron van de bug - het stellen van de label te schilderen is geen misdaad.

Van daar, keek ik naar elk aspect van de verf oproep die werd crashen (drawString) om te zien wat ongeldig zou kunnen zijn en begon aan een ieder uit te sluiten totdat hij viel op de wegwerpartikelen. Ik vervolgens bepaald welke we controle hadden over en het lettertype was de enige. Dus nam ik een blik op hoe we het lettertype behandeld en onder welke omstandigheden we weggegooid het naar eventuele onderliggende oorzaken te identificeren. Ik kon komen met een plausibele samenloop van omstandigheden die de rapporten passen van gebruikers, en daardoor in staat een laag risico fix coderen.

Natuurlijk, het door mijn hoofd dat het probleem was in het kader, maar ik neem aan dat we screwed up alvorens de schuld van Microsoft.

Conclusie

Dus, dat is hoe ik benaderde een bijzonder voorbeeld van dit soort problemen. Zoals je kunt zien, het is minder dan ideaal, maar past bij wat velen hebben gezegd.

Voor een moeilijk te reproduceren fout, de eerste stap is meestal documentatie. Op het gebied van de code die er niet in slaagt, wijzigen van de code hyper-expliciet te zijn: één commando per regel; zwaar, gedifferentieerde exception handling; breedsprakig, zelfs prolix debug output. Op die manier, zelfs als je niet kunt reproduceren of repareren de fout, kunt u veel meer informatie te krijgen over de oorzaak van de volgende keer dat het falen wordt gezien.

De tweede stap is gewoonlijk stelling aannames verlopen controleren. Alles wat je denkt te weten over de code in kwestie, schrijft .Asserts en cheques. In het bijzonder, check-objecten voor nietigheid en (als uw taal is dynamisch) bestaan.

Ten derde, controleer je unit test dekking. Gebruik uw unit tests eigenlijk te dekken elke vork in de uitvoering? Als u niet unit tests hebben, is dit waarschijnlijk een goede plek om te beginnen.

Het probleem met reproduceerbaar fouten is dat ze alleen reproduceerbaar aan de ontwikkelaar. Als uw eindgebruikers aandringen op hen te reproduceren, het is een waardevol instrument om de crash in het veld te benutten.

U zegt in een reactie dat je denkt dat het een race condition. Als je denkt dat je weet wat "feature" van de code is het genereren van de aandoening kun je schrijven een test om te proberen te forceren.

Hier is wat riskant code in c:

const int NITER = 1000;
int thread_unsafe_count = 0;
int thread_unsafe_tracker = 0;

void* thread_unsafe_plus(void *a){
  int i, local;
  thread_unsafe_tracker++;
  for (i=0; i<NITER; i++){
    local = thread_unsafe_count;
    local++;
    thread_unsafe_count+=local;
  };
}
void* thread_unsafe_minus(void *a){
  int i, local;
  thread_unsafe_tracker--;
  for (i=0; i<NITER; i++){
    local = thread_unsafe_count;
    local--;
    thread_unsafe_count+=local;
  };
}

die ik kan testen (in een pthreads enironment) met:

pthread_t th1, th2;
pthread_create(&th1,NULL,&thread_unsafe_plus,NULL);
pthread_create(&th2,NULL,&thread_unsafe_minus,NULL);
pthread_join(th1,NULL);
pthread_join(th2,NULL);
if (thread_unsafe_count != 0) {
  printf("Ah ha!\n");
}

In het echte leven, zult u waarschijnlijk moet je verdachte code te wikkelen op een bepaalde manier te helpen de race raakte meer ofter.

Als het werkt, pas het aantal draden en andere parameters om het grootste deel van de tijd geraakt, en nu heb je een kans.

Ik heb tegenkomen bugs op systemen die lijken te consequent fouten veroorzaken, maar wanneer het doorlopen van de code in een debugger het probleem op mysterieuze wijze verdwijnt. In al deze gevallen was de kwestie één van timing.

Wanneer het systeem normaal liep was er een soort van conflict voor de middelen of het nemen van de volgende stap voor de laatste eindigde. Toen ik er doorheen stapte in de debugger, zijn dingen in beweging langzaam genoeg dat het probleem verdwenen.

Zodra ik dacht dat het was een kwestie van timing was het gemakkelijk om een ​​oplossing te vinden. Ik weet niet zeker of dit in uw situatie van toepassing is, maar wanneer bugs verdwijnen in de debugger timing problemen zijn mijn eerste verdachten.

Tenzij er grote tijdsdruk, weet ik niet beginnen met het testen veranderingen, totdat ik op betrouwbare wijze het probleem kan reproduceren.

Als je echt moest, ik veronderstel dat je kon een testcase die lijkt te zijn het probleem soms veroorzaken, en deze toevoegen aan uw geautomatiseerde test suite te schrijven (je moet wel een geautomatiseerde test suite, toch?), En dan maak je verandering en hoop dat testcase faalt nooit meer, wetende dat als je niet echt iets vast te stellen op zijn minst heb je nu meer kans op het vangen van het. Maar tegen de tijd kunt u een test case te schrijven, heb je bijna altijd dingen teruggebracht tot het punt waar je niet meer te maken hebt met een dergelijke (blijkbaar) niet-deterministische situatie.

Zodra u het insect volledig te begrijpen (en dat is een grote "eens"), moet u in staat om het te reproduceren op wil. Wanneer de reproductie code (automatische test) is geschreven, je de bug te herstellen.

Hoe kan ik het punt te komen waar je de bug te begrijpen?

Instrument de code (log als een gek). Werk samen met uw QA - ze goed in zijn re-creëren van het probleem, en je moet regelen om volledige dev toolkit voor u beschikbaar op hun machines te hebben. Gebruik geautomatiseerde tools voor niet-geïnitialiseerd geheugen / resources. Gewoon staren naar de code. Geen gemakkelijke oplossing daar.

Simpel: de gebruiker vragen die het gemeld.

Ik gebruik gewoon een van de verslaggevers als een verificatiesysteem. Meestal is de persoon die bereid zijn om een ​​bug te melden was is meer dan blij om u te helpen haar probleem [1] op te lossen. Geef haar versie met een mogelijke oplossing en vragen of het probleem is verdwenen. Indien de fout een regressie, kan dezelfde werkwijze worden gebruikt voor doorsnijden wanneer het probleem optrad door aan de gebruiker het probleem meerdere versies te testen. In andere gevallen kan de gebruiker die u ook helpen om het probleem debuggen door het geven van haar een versie met meer debugging mogelijkheden.

Dit zal alle negatieve effecten van een mogelijke oplossing te beperken tot die persoon in plaats van gissen dat er iets aan de bug later vast te stellen en vervolgens te beseffen dat je net hebt bracht een "bug fix" dat er geen effect of in het ergste geval een negatief effect heeft de systeemstabiliteit.

U kunt ook de mogelijke negatieve gevolgen van de "bug fix" te beperken door het geven van de nieuwe versie van een beperkt aantal gebruikers (bijvoorbeeld om alle van degenen die het probleem gerapporteerd) en het vrijgeven van de fix pas daarna.

Ook degenen van wie ze kan bevestigen dat de fix je hebt werken, gemaakt, is het gemakkelijk om tests die zorgt ervoor dat uw fix zal blijven in de code (tenminste op unit test niveau, als de bug is moeilijk te reproduceren op meer hoger systeemniveau toe te voegen ).

Dit vereist natuurlijk dat alles wat u bezig bent ondersteunt deze aanpak. Maar als het niet zou ik echt doen wat ik kan om haar in staat - de eindgebruikers zijn meer tevreden en veel van de zwaarst tech problemen gewoon weg te gaan en prioriteiten komen duidelijk wanneer de ontwikkeling rechtstreeks kan communiceren met het systeem eindgebruikers.

[1] Als je ooit een fout hebben gemeld, u waarschijnlijk weet dat vele malen het antwoord van de ontwikkeling / onderhoud team is een of andere manier negatief uit de eindgebruikers standpunt of er helemaal geen reactie - vooral in situaties waarin de bug kan niet worden gereproduceerd door het ontwikkelteam.