• Een bug is het resultaat van een coderingsfout

• Een defect is een afwijking van de vereisten

Dat is: een defect betekent niet noodzakelijk dat er een bug in de code zit, het kan een functie zijn die niet werd geïmplementeerd maar gedefinieerd in de vereisten van de software.

Van de Wikipedia-pagina op softwaretests :

Niet alle softwarefouten worden veroorzaakt door coderingsfouten. Een veelvoorkomende bron van dure defecten wordt veroorzaakt door hiaten in de vereisten, bijvoorbeeld niet-herkende vereisten, die resulteren in weglatingsfouten door de programmaontwerper. [14] Een veel voorkomende bron van hiaten in vereisten zijn niet-functionele vereisten zoals testbaarheid, schaalbaarheid, onderhoudbaarheid, bruikbaarheid, prestaties en beveiliging.

Opmerkingen

• Beide zijn ” afwijkingen van vereisten ” zoals ik het zie.
• Een defect hoeft niet ‘ t een bug te zijn. Bovendien hoeft een bug niet ‘ te betekenen dat er niet aan een vereiste was voldaan, en is daarom geen ‘ een afwijking van vereiste ‘
• Je lijkt het punt te missen @Martin. Ja, een bug kan een defect zijn. Ja, een defect kan een bug zijn. Maar dat is niet ‘ niet noodzakelijk altijd waar. Alleen omdat er enige overlap is, betekent ‘ niet dat ze identiek zijn! Venn-diagram van bug & Defect – > (())
• @Dan McGrath: wat je hier in feite deed, is je eigen definitie van een bug. Maar in het algemeen is er geen ‘ een gedefinieerde betekenis, het is ‘ slechts een technisch jargon!
• @DanMcGrath : Uw Venn-diagram is nutteloos. Het kan ({}) of ({)} betekenen. Ik neem aan dat je de tweede bedoelde.

Ik citeer Ilene Burnstein uit het boek Praktische softwaretests (aanbevolen) die deel uitmaakt van de definitie in de” IEEE-normen Collection for Software Engineering “(1994) en” IEEE Standard Glossary of Software Engineering Terminology “(standard 610.12, 1990):

Fout

Een fout is een vergissing, misvatting of misverstand van de kant van een softwareontwikkelaar

In de categorie ontwikkelaar omvatten we software-ingenieurs, programmeurs, analisten en testers. Een ontwikkelaar kan bijvoorbeeld een ontwerpnotatie verkeerd begrijpen, of een programmeur kan een variabelenaam verkeerd typen.

Fouten (defecten)

Een fout (defect) is geïntroduceerd in de software als gevolg van een fout. Het is een anomalie in de software die ervoor kan zorgen dat deze zich niet correct gedraagt, en niet volgens de specificaties.

Fouten of defecten worden soms “bugs” genoemd. Het gebruik van de laatste term bagatelliseert de impact van fouten op de softwarekwaliteit. Het gebruik van de term “defect” wordt ook in verband gebracht met software-artefacten zoals vereisten en ontwerpdocumenten. Defecten in deze artefacten worden ook veroorzaakt door fouten en worden meestal gedetecteerd tijdens het beoordelingsproces.

Storingen

Een storing is het onvermogen van een softwaresysteem of -component om de vereiste functies uit te voeren binnen gespecificeerde prestatie-eisen.

Tijdens de uitvoering van een softwarecomponent of -systeem, een tester, ontwikkelaar, of de gebruiker merkt op dat het niet de verwachte resultaten oplevert. In sommige gevallen geeft een bepaald type wangedrag aan dat er een bepaald type fout aanwezig is. We kunnen zeggen dat het soort wangedrag een symptoom is van de fout.Een ervaren ontwikkelaar / tester heeft een kennisbank van fout / symptomen / foutgevallen (foutmodellen zoals beschreven in hoofdstuk 3) opgeslagen in het geheugen. Onjuist gedrag kan bestaan uit het produceren van onjuiste waarden voor uitvoervariabelen, een onjuiste reactie van een apparaat of een onjuiste afbeelding op een scherm. Tijdens de ontwikkeling worden fouten meestal waargenomen door testers, en fouten worden gelokaliseerd en gerepareerd door ontwikkelaars.

U kunt het volledige hoofdstuk lezen in Google Books, hier .

Er zijn enkele verschillende termen gerelateerd aan softwarefouten. Uittreksel uit een cursus die ik heb gevolgd:

• Fout : menselijk handelen of nalaten dat resulteert in een fout.

• Fout : Fout is software defect (onjuiste stap, proces of gegevensdefinitie) die een fout veroorzaakt.

• Bug : hetzelfde als fout.

• Fout : de onvermogen van een software om zijn vereiste functies uit te voeren binnen gespecificeerde prestatie-eisen.

Volgens dit is er geen verschil tussen een defect en een bug. Sommige mensen beweren echter dat een bug een fout is die wordt gevonden voordat de software wordt vrijgegeven, terwijl een defect wordt gevonden door de klant.

Ik kon het niet laten om het beroemde eerste echte geval van een gevonden bug te plaatsen “.

Reacties

• Eindelijk, iemand die heeft gelezen: testingstandards.co.uk/bs_7925-1_online.htm
• Dat ‘ s niet waar ik het vandaan heb, maar ze kunnen een gemeenschappelijke bron hebben (of deze kan de bron zijn).
• Ja, vele, vele jaren geleden heb ik een tijdje geprobeerd een bug op te lossen. Ik had wat vervelende flikkeringen in een cel op het scherm en het sloeg nergens op. Het vloog eindelijk weg. (dit was in het tijdperk van witte tekst op een zwart scherm, de plek in kwestie was ver genoeg naar rechts om altijd zwart te zijn terwijl Ik was aan het bewerken, dus ik merkte het pas toen het programma er wat wit achter zette.)

Oh jee.

Vroeger – defecte werking van een computer werd veroorzaakt door allerlei dingen – inclusief ratten die op de bedrading kauwden en echte beestjes (beestjes) die aan het werk kwamen.

De term BUG is blijven hangen als een term die betekent dat iets niet werkt zoals verwacht.

BUG moet worden gezien als een jargonterm die een defect betekent.

Een defect is een technisch correcte term die betekent dat het ding niet doet zoals het zou moeten.

Waar mogelijk heeft het gebruik van DEFECT in plaats van BUG de connotatie dat we onze fouten erkennen (onze defecten, ons gebrek aan kennis van gebruikersvereisten of de dingen die we bij de implementatie over het hoofd hebben gezien) in plaats van het te verkleden als de meer triviaal klinkende “bug”.

Gebruik DEFECT.

Probeer de term BUG niet te gebruiken. Het is dom, irrelevant, historisch en trivialiserend.

Opmerkingen

• Waarom zou je een goed begrepen technische term uit het gebruik willen verwijderen? Ik ‘ m sorry … ja, BUG is historisch – maar als je denkt dat programmeurs bugs (algemeen in plaats van specifiek) als triviaal beschouwen alleen omdat ze ‘ worden bugs genoemd of de term als irrelevant vanwege de oorsprong, dan ben ik ‘ bang dat het helemaal terecht is dat ik een knorrige middelbare leeftijd word. Oh en zoals @Dan aangeeft, bugs zijn defecten, maar defecten zijn niet ‘ noodzakelijkerwijs bugs, wat verder suggereert dat de term waarde heeft.
• @Murph, een ” bug ” is een eufemisme voor een programmeerfout. Dit lokt onbewust een soort gremlin uit waar de ontwikkelaar geen controle over heeft. Dit is niet correct – het is is een fout en het erkennen dat dit een stap is in de richting van professioneler gedrag. (Imho natuurlijk :-))
• Erm, ik ben het duidelijk niet eens (-: ik weet precies wie verantwoordelijk is voor de bugs – coderings- en logische fouten – die ik in mijn code heb. (I ‘ m ook in staat om tekortkomingen bij andere mensen te identificeren ‘ s code.) Alle programmeurs die ik ken zijn duidelijk over wat de term betekent – dat ze ( nou ja, een of andere programmeur) en niet een of andere gremlin die een fout heeft gemaakt.
• In de omgang met uw klanten kunt u deze dingen bugs of defecten noemen. Bugs is jargon. Defecten is een erkenning, buiten het jargon, om het is niet zoals het zou moeten zijn. ” Defecten ” is een term die duidelijke communicatie is, en aanmoedigt, ook buiten de programmerende broederschap als binnen.(Ik ben het er ook niet mee eens dat er een verschil is tussen een bug en een defect.)
• Defecten is de juiste term. Hoeveel programmas worden er uitgebracht met bugs erin en dat accepteren we allemaal? Maar hoeveel programmas worden er uitgebracht met defecten? We zouden dat niet ‘ accepteren, omdat de term een grotere ernst impliceert en we weten dat het ‘ onze eigen fout is, eerder dan een bug waar we het weer of de tijd van de dag de schuld kunnen geven.

Van de IEEE-norm Verklarende woordenlijst van Software Engineering Terminology, die wordt aangehaald in de Software Engineering Body of Knowledge KA for Software Testing and Software Quality:

bug. Zie: fout; fout.

fout. (1) Het verschil tussen een berekende, waargenomen of gemeten waarde of conditie en de ware, gespecificeerde of theoretisch correcte waarde of conditie. Bijvoorbeeld een verschil van 30 meter tussen een berekend resultaat en het juiste resultaat. (2) Een onjuiste stap, proces of gegevensdefinitie. Bijvoorbeeld een onjuiste instructie in een computerprogramma. (3) Een onjuist resultaat. Bijvoorbeeld een berekend resultaat van 12 wanneer het juiste resultaat 10 is. (4) Een menselijke handeling die een onjuist resultaat oplevert. Bijvoorbeeld een foutieve handeling van een programmeur of operator. Opmerking: hoewel alle vier de definities algemeen worden gebruikt, kent één onderscheid definitie 1 toe aan het woord “fout”, definitie 2 aan het woord “fout”, definitie 3 aan het woord “mislukking” en definitie 4 aan het woord “fout”. Zie a2so: dynamische fout; fatale fout; inheemse fout; semantische fout; syntactische fout; statische fout; tijdelijke fout.

fout. Het onvermogen van een systeem of onderdeel om de vereiste functies uit te voeren binnen gespecificeerde prestatie-eisen. Opmerking: De fouttolerantiediscipline maakt onderscheid tussen een menselijke handeling (een fout), de manifestatie ervan (een hardware- of softwarefout), het resultaat van de fout (een fout) en de mate waarin het resultaat onjuist is (de fout). Zie ook: crash; afhankelijke mislukking; uitzondering; faal modus; uitvalpercentage; harde mislukking; beginnende mislukking; onafhankelijk falen; willekeurige mislukking; zachte mislukking; vastgelopen fout.

fout. (1) Een defect in een hardwareapparaat of onderdeel; bijvoorbeeld een kortsluiting of een gebroken draad. (2) Een onjuiste stap, proces of gegevensdefinitie in een computerprogramma. Opmerking: deze definitie wordt voornamelijk gebruikt door de fouttolerantiediscipline. In het algemeen worden de termen “fout” en “bug” gebruikt om deze betekenis uit te drukken. Zie ook: datagevoelige storing; programmagevoelige fout; gelijkwaardige fouten; foutmaskering; intermitterende fout.

Ik denk dat de definitie van mislukking het meest relevant is. Alles begint met een fout, of het nu in de vereisten, het ontwerp, de implementatie of de testcase / procedure zit. Als deze fout zich manifesteert in software, wordt het een fout. Een fout wordt veroorzaakt door het bestaan van een of meer fouten in software.

Ik ben echter niet zo happig op de formele definitie van fouten. Ik geef de voorkeur aan de definitie die dukeofgaming in zijn antwoord geeft, maar die in dit antwoord is de IEEE-standaarddefinitie van fout.

Dan McGraths antwoord heeft het goed gedaan.

• Een bug is het resultaat van een coderingsfout
• Een defect is een afwijking van de vereisten

Misschien zou een voorbeeld het duidelijker maken.

Voorbeeld: de klant wilde dat het webformulier het venster kon opslaan en sluiten.

Scenario # 1: webformulier heeft een knop Opslaan en een andere knop Sluiten. Resultaat: defect, omdat de klant de 1-knop wilde hebben om het venster op te slaan en te sluiten. Ontwikkelaar heeft het verkeerd begrepen en afzonderlijk gemaakt. Omdat beide knoppen aan hun vereisten voldeden, is het geen bug, maar een defect omdat het niet aan de vereisten van de klant voldeed.

Scenario 2: webformulier heeft een knop Opslaan & sluiten, maar slaat alleen op maar sluit niet. Resultaat: Bug. Omdat de knop niet presteert zoals vereist / verwacht. Ontwikkelaar weet dat het verondersteld wordt dat resultaat te produceren, maar uiteindelijk deed het het niet. (Misschien coderingsfout)

Weet niet zeker of dit het duidelijker maakt.

p / s: van een ontwikkelaar standpunt (ik was ooit), zijn zowel defecten als bugs net zo belangrijk. We zullen het nog steeds oplossen.

We zijn zelfs rare anomalieën tegengekomen, die we hebben gecategoriseerd onder bugs en we proberen continu te achterhalen wat is de oorzaak en hoe deze te verhelpen. Het noemen van bugs maakt het niet triviaal vergeleken met defecten.

Opmerkingen

• Wat noemen we defecte vereisten?
• @ gnasher729 als je met foute vereisten bedoelde dat de programmeurs de vereisten verkeerd begrepen, dan zou ik denken dat het ‘ een defect is. Maar als u verkeerde vereisten bedoelde, aangezien de gebruiker die de verkeerde vereisten verstrekt, met als resultaat dat het uiteindelijke werk het oorspronkelijke probleem niet oplost, dan is dat meer dan alleen bugs en defecten aangezien dit een probleem is met de sessie voor het verzamelen van vereisten in plaats van met de ontwikkeling. li>

Hier is er een die ik eerder deed voor mijn werkgever Q-LEAP op basis van het ISTQB-vocabulaire en ik heb ook gecontroleerd het IEEE-vocabulaire. Genieten.

Bug en defect? Hetzelfde ook al kan hierover eindeloos gediscussieerd worden. We hebben echt andere dingen om ons zorgen over te maken, het leven is al gecompliceerd genoeg, enz.

Een voorbeeld van hoe de term in het wild wordt gebruikt, van “Hoe Google software test” p. 113. Open een artikel van “IEEE Software” en het wordt op dezelfde manier gebruikt. In het echte leven kom je inderdaad zelden het woord “defect” tegen.

Life of a Bug

Bugs en bugrapporten zijn het enige artefact dat elke tester begrijpt. Het vinden van bugs, het testen van bugs, het oplossen van bugs en het oplossen van bugs zijn de hartslag en workflow voor softwarekwaliteit. Dit is het deel van testen dat het meest conventioneel is bij Google, maar er zijn nog een paar interessante afwijkingen van de norm. Voor deze sectie negeren we de bugs die worden ingediend om werkitems bij te houden en gebruiken we de term om daadwerkelijk kapotte code. Als zodanig vertegenwoordigen bugs vaak de uur-tot-uur en dagelijkse workflow voor engineeringteams.

Een bug is geboren. Bugs worden gevonden en ingediend door iedereen bij Google. Product Managers melden bugs wanneer ze problemen ontdekken in de vroege builds die verschillen van hun specificaties / gedachten. Ontwikkelaars melden bugs wanneer ze beseffen dat ze per ongeluk een probleem hebben ingecheckt of een probleem ergens anders in de codebase of tijdens het dogfooden van Google-producten. Bugs komen ook binnen vanuit het veld, van crowdsourcing-testers, testen van externe leveranciers, en worden ingediend door communitymanagers die de productspecifieke Google Discussiegroepen controleren. Veel interne versies van apps hebben ook snelle manieren om met één klik bugs te melden, zoals Google maps. En soms creëren softwareprogrammas bugs via een API.

Het verschil is dat de term “bug” magisch klinkt. Alsof een programma willekeurig bugs kan bevatten nadat u klaar bent met programmeren. Als het willekeurige bugs bevat, betekent dit dat u zich niet aan de specificaties heeft gehouden en dat uw programma een fout maakt.

Een defect betekent een fout waarbij het programma niet voldoet aan de specificaties. Dit is ernstiger en zegt in feite: elke fout is een enorm probleem met het programma en dit betekent dat het programma is niet geschikt om te worden vrijgegeven.

Het verschil zit in de houding van de programmeurs die de termen gebruiken. Er zijn miljoenen programmas die worden uitgebracht met bugs en mensen vinden dat prima omdat ze om de een of andere reden accepteren dat een bug magisch en willekeurig is en dat elk programma minstens één bug bevat. Een programmeur die de term “defect” gebruikt, kan zich echter ongemakkelijk voelen bij het vrijgeven van een programma met een defect, omdat de term een grotere ernst impliceert.

De implicaties van het verkiezen van de ene term boven de andere beïnvloeden ons dagelijks.

Buiten een specifieke bug / taak / ticket / defect / probleem / welk volgsysteem dan ook, hebben deze woorden geen exacte betekenis en daarom is het zinloos om het verschil tussen beide te bespreken. Als je je werkstroom regelt, moet je de terminologie regelen en beschrijvingen geven.

In mijn huidige omgeving is een “defect” elk item in Jira. Het lijkt erop dat Jira zelf de term “probleem” gebruikt. We hebben het misschien geërfd van een eerder systeem.”Bug” is een soort probleem wanneer iets niet werkt zoals verwacht en wordt beschreven in de documentatie. “Feature request” wanneer iets werkt zoals verwacht maar verbetering gewenst is (het kan duidelijk en belangrijk zijn, maar als het huidige gedrag wordt beschreven, is het nog steeds een feature request). Er zijn meer typen, maar die 2 worden door mensen buiten het ontwikkelteam gebruikt om er iets van te vragen.

Als je namen kiest voor probleemtypen, klinken “bug” en “defect” hetzelfde als ik. Het verschil tussen hen is stilistisch. Aangezien Engels niet mijn moedertaal is, kan ik er niet veel van zien en weet ik niet zeker of wat ik zie correct is.