Citera Ilene Burnstein från boken Praktisk programvarutestning (rekommenderas) vem som skiljer sig från definitionen i” IEEE-standarderna Samling för programvaruteknik ”(1994) och” IEEE-standardordlista för programvaruteknik ”(standard 610.12, 1990):

Fel

Ett fel är ett misstag, missuppfattning eller missförstånd hos en programvaruutvecklare

I kategorin utvecklare inkluderar vi programvaruutvecklare, programmerare, analytiker och testare. Till exempel kan en utvecklare missförstå en designnotation, eller så kan en programmerare skriva ett variabelnamn felaktigt.

Fel (defekter)

Ett fel (defekt) införs i programvaran som ett resultat av ett fel. Det är en anomali i programvaran som kan få den att fungera felaktigt och inte enligt dess specifikation.

Fel eller defekter kallas ibland ”buggar”. Användningen av den sistnämnda termen bagatelliserar inverkan på programvarans kvalitet. Användningen av termen ”defekt” är också associerad med programvaruartiklar som krav och designdokument. Fel som uppstår i dessa artefakter orsakas också av fel och detekteras vanligtvis i granskningsprocessen.

Fel

Ett misslyckande är oförmågan för ett programvarusystem eller komponent att utföra sina nödvändiga funktioner inom specificerade prestandakrav.

Under körning av en programvarukomponent eller ett system, testar, utvecklar eller användaren observerar att den inte ger de förväntade resultaten. I vissa fall indikerar en viss typ av felaktigt beteende att en viss typ av fel är närvarande. Vi kan säga att typen av felaktigt beteende är ett symptom på felet.En erfaren utvecklare / testare har en kunskapsbas om fel / symtom / felfall (felmodeller som beskrivs i kapitel 3) lagrade i minnet. Felaktigt beteende kan innefatta att producera felaktiga värden för utdatavariabler, ett felaktigt svar från en enhet eller en felaktig bild på en skärm. Under utveckling observeras vanligtvis misslyckanden av testare och fel lokaliseras och repareras av utvecklare.

Du kan läsa hela kapitlet i Google Böcker, här .

Det finns olika termer relaterade till programfel. Utdrag från en kurs jag tog:

• Fel : Mänsklig handling eller utelämning som leder till ett fel.

• Fel : Fel är en programvara defekt (felaktigt steg, process eller datadefinition) som orsakar ett misslyckande.

• Fel : Samma som fel.

• Fel : oförmåga hos en programvara att utföra sina nödvändiga funktioner inom specificerade prestandakrav.

Enligt detta är det ingen skillnad mellan en defekt och ett fel. Vissa människor hävdar emellertid att fel är ett fel som hittas innan programvaran släpps, medan defekten är en som kunde hittas.

Jag kunde inte motstå att publicera det berömda ”första faktiska fallet med att fel hittades. ”.

Kommentarer

• Slutligen någon som har läst: testingstandards.co.uk/bs_7925-1_online.htm
• Att ’ s inte var jag fick det från, men de kan ha en gemensam källa (eller den här kan vara källan).
• Japp, för många, många år sedan tillbringade jag ett tag på att fixa ett fel. hade lite irriterande flimmer i en cell på skärmen och det gav ingen mening. Det flög äntligen av. (Detta var i tiden med vit text på en svart skärm, platsen i fråga var tillräckligt långt till höger för att alltid vara svart medan Jag redigerade, så jag märkte det bara när programmet lade lite vitt bakom det.)

Kära nån.

Tillbaka i gamla tider – defekt drift av en dator orsakades av alla möjliga saker – inklusive råttor som tuggade ledningarna och riktiga buggar (kritiker) som kom in i arbetet.

term BUG har fastnat som en term som betyder att något inte fungerar som förväntat.

BUG bör betraktas som en jargongtermer som betyder en defekt.

En defekt är en tekniskt korrekt term som betyder att saken inte gör som den ska.

När det är möjligt använder DEFECT istället för BUG faktiskt en konnotation om att vi erkänner våra misslyckanden (våra brister, vår bristande förståelse för användarkraven eller sakerna vi förbises i implementeringen) istället för att klä upp det som det mer triviala klingande ”bug”.

Använd DEFECT.

Försök att inte använda termen BUG. Det är dumt, irrelevant, historiskt och trivialt.

Kommentarer

• Varför skulle du vilja ta bort en välförstått teknisk term från användningen? Jag ’ ledsen … ja, BUG är historiskt – men om du tycker att programmerare ser buggar (generellt i motsats till specifika) som triviala bara för att de ’ kallas buggar eller termen som irrelevant på grund av dess ursprung så jag ’ är rädd att jag blir en grinig medelålders är helt berättigad. Åh och som @Dan påpekar är buggar defekter men defekter är inte ’ t nödvändigtvis buggar, vilket ytterligare antyder att termen har värde.
• @Murph, a ” bug ” är en eufemism för ett programmeringsfel. Omedvetet lockar detta till ett slags gremlin som utvecklaren inte har någon kontroll över. Detta är inte korrekt – det är ett fel och att erkänna detta är ett steg mot mer professionellt beteende. (Imho självklart :-))
• Erm, helt klart håller jag inte med (-: Jag vet exakt vem som är ansvarig för buggarna – kodning och logiska fel – som jag har i min kod. (I ’ Jag kan också identifiera fel hos andra människor ’ s kod.) Alla programmerare jag känner är tydliga om vad termen betyder – att de ( väl någon programmerare) och inte någon form av gremlin gjorde ett misstag.
• När du handlar med dina kunder kan du kalla dessa saker buggar eller defekter. Bugs är jargong. Defekter är en bekräftelse, utanför jargongen, att det är inte som det borde vara. ” Defekter ” är en term som är och uppmuntrar till tydlig kommunikation – även utanför programmeringsbrödraskapet som inuti.(Jag håller inte med om att det finns en skillnad mellan ett fel och en defekt.)
• Defekter är den rätta termen. Hur många program släpps med fel i dem och det accepterar vi alla? Men hur många program släpps med defekter? Vi skulle inte ’ t acceptera det eftersom termen innebär en större svårighetsgrad och vi vet att det ’ är vårt eget fel för felet, snarare än ett fel där vi kan skylla på vädret eller tiden på dagen.

Från IEEE-standarden Ordlista med programvaruteknikterminologi, som citeras i Software Engineering Body of Knowledge KA för programvarutestning och programvarukvalitet:

bug. Se: fel; fel.

fel. (1) Skillnaden mellan ett beräknat, observerat eller uppmätt värde eller tillstånd och det sanna, specificerade eller teoretiska korrekta värdet eller tillståndet. Till exempel en skillnad på 30 meter mellan ett beräknat resultat och rätt resultat. (2) Felaktigt steg, process eller datadefinition. Till exempel en felaktig instruktion i ett datorprogram. (3) Ett felaktigt resultat. Till exempel ett beräknat resultat på 12 när rätt resultat är 10. (4) En mänsklig handling som ger ett felaktigt resultat. Till exempel en felaktig åtgärd hos en programmerare eller operatör. Obs! Medan alla fyra definitionerna ofta används, tilldelar en skillnad definition 1 till ordet ”fel”, definition 2 till ordet ”fel”, definition 3 till ordet ”misslyckande” och definition 4 till ordet ”fel.” Se a2so: dynamiskt fel; allvarligt fel; inhemskt fel semantiskt fel syntaktiskt fel statiskt fel övergående fel.

fel. Ett systems eller komponents oförmåga att utföra sina nödvändiga funktioner inom specificerade prestandakrav. Anmärkning: Feltoleransdisciplinen skiljer mellan en mänsklig handling (ett misstag), dess manifestation (ett hårdvaru- eller programvarufel), resultatet av felet (ett fel) och det belopp med vilket resultatet är felaktigt (felet). Se även: krasch; beroende fel undantag; feltillstånd; felprocent; hårt misslyckande; begynnande misslyckande; oberoende fel slumpmässigt fel mjukt fel fastnat fel.

fel. (1) En defekt i en hårdvaruenhet eller komponent; till exempel en kortslutning eller trasig ledning. (2) Felaktigt steg, process eller datadefinition i ett datorprogram. Obs: Denna definition används främst av feltoleransdisciplinen. Vid vanlig användning används termerna ”fel” och ”bugg” för att uttrycka denna betydelse. Se även: datakänsligt fel; programkänsligt fel motsvarande fel felmaskering; intermittent fel.

Jag tycker att definitionen av fel är den mest relevanta. Allt börjar med ett misstag, oavsett om det är i kraven, designen, implementeringen eller testfallet / proceduren. Om detta misstag manifesteras i programvara blir det ett fel. Ett fel orsakas av förekomsten av en eller flera fler fel i programvaran.

Jag vill dock inte ha den formella definitionen av fel. Jag föredrar mycket definitionen som dukeofgaming tillhandahåller i hans svar , men den i detta svar är IEEE-standarddefinitionen av fel.

Dan McGraths svar spikade rätt.

• Ett fel är resultatet av ett kodfel
• En defekt är en avvikelse från kraven

Ett exempel skulle kunna göra det tydligare.

Exempel: Klienten ville att webbformuläret skulle kunna spara och stänga fönstret.

Scenario nr 1: Webbformuläret har en spara-knapp och en annan stängningsknapp. Resultat: Defekt, eftersom klienten ville att 1-knappen skulle spara och stänga fönstret. Utvecklare missförstod och skapade separat. Eftersom båda knapparna uppfyllde sina krav är det inte ett fel, utan ett fel eftersom det inte uppfyllde kundens krav.

Scenario nr 2: Webbformuläret har en spara & stängningsknapp, men sparar bara men stängs inte. Resultat: Insekt. Eftersom knappen inte fungerar som krävs / förväntat. Utvecklare vet att det antas att producera det resultatet men i slutändan gjorde det inte (kanske kodningsfel)

Inte säker på om detta gör det tydligare.

p / s: från en utvecklare standpunkt (jag var en gång), både defekter och buggar är lika viktiga. Vi fixar det fortfarande. är orsaken och hur man åtgärdar det. Att beteckna det fel gör det inte trivialt jämfört med defekter.

Kommentarer

• Vad kallar vi felaktiga krav?
• @ gnasher729 om du med felaktiga krav menade att programmerarna missförstod kraven, då skulle jag tro att det ’ är en defekt. Men om du menade felaktiga krav eftersom användaren som tillhandahåller fel krav som resulterar i det slutliga arbetet inte löser det ursprungliga problemet, så är det bortom fel och defekt eftersom det här är ett problem med kravsamlingssessionen snarare än med utvecklingen.

Här är en jag gjorde tidigare för min arbetsgivare Q-LEAP baserat på ISTQB-ordförrådet och jag kollade också IEEE-ordförrådet. Njut av.

Fel och fel? Detsamma även om man kan ha oändlig diskussion om detta. Vi har verkligen andra saker att oroa oss för, livet är redan tillräckligt komplicerat osv.

Ett exempel på hur termen används i naturen, från ”Hur Google testar programvara” s. 113. Öppna en artikel av ”IEEE-programvara” och den används på samma sätt. Man möter sällan ordet ”defekt” i verkliga livet.

Bugens liv

Buggar och bugrapporter är den artefakt som varje testare förstår. Att hitta buggar, triaging buggar, fixa buggar och regressera buggar är hjärtslag och arbetsflöde för mjukvarukvalitet. Det här är den del av testningen som är den mest konventionella hos Google, men det finns fortfarande några intressanta avvikelser från normen. För detta avsnitt ignorerar vi buggarna som arkiveras för att spåra arbetsobjekt och använder termen för att identifiera faktiskt trasig kod. Som sådan representerar buggar ofta tim-till-timme och dag-till-dag arbetsflödet för ingenjörsteam.

Ett fel uppstår. Fel hittas och arkiveras av alla på Google. Chefer arkiverar buggar när de fångar problem i de tidiga byggnader som skiljer sig från deras specifikationer / tankar. Utvecklare arkiverar buggar när de inser att de av misstag kollade in ett problem eller hittar ett problem någon annanstans i kodbasen, eller medan du äter Googles produkter. Fel kommer också in från fältet, från testare från folkmassan, externa leverantörstester och arkiveras av gemenskapschefer som övervakar de produktspecifika Google-grupperna. Många interna versioner av appar har också snabba sätt att klicka på fel med ett klick, som Google maps. Och ibland skapar programprogram buggar via ett API.

Skillnaden är att termen ”bug” låter magiskt. Som om ett program slumpmässigt kan ha fel i det efter att du har programmerat. Om det har slumpmässiga buggar betyder det att du inte överensstämde med specifikationerna och att ditt program är fel.

Ett fel betyder ett fel där programmet inte överensstämmer med specifikationerna. Detta är allvarligare och säger i princip något fel är ett stort problem med programmet och det betyder att programmet är inte lämpligt att släppas.

Skillnaden ligger i attityden hos programmerarna som använder termerna. Det finns miljontals program som släpps med buggar och folk är bra med det eftersom de accepterar av någon anledning att en bugg är magisk och slumpmässig och att varje program innehåller minst en bugg. En programmerare som använder termen ”defekt” kan dock bli obekväm med att släppa ett program med en defekt eftersom termen innebär en större svårighetsgrad.

Konsekvenserna av att föredra en term framför den andra påverkar oss dagligen.

Utanför specifika fel / uppgift / biljett / defekt / problem / oavsett spårningssysteminstans har dessa ord ingen exakt betydelse och därför är det meningslöst att diskutera skillnad mellan dem. När du löser ditt arbetsflöde bör du ordna terminologin och ge beskrivningar.

I min nuvarande miljö är en ”defekt” något objekt i Jira. Ser ut som att Jira själv använder termen ”issue”. Vi kan ha ärvt det från något tidigare system.”Bug” är en typ av problem när något inte fungerar som förväntat och beskrivs i dokumentationen. ”Funktionsbegäran” när något fungerar som förväntat men önskan är impvovement (det kan vara uppenbart och viktigt, men om det aktuella beteendet beskrivs är det fortfarande en funktionsbegäran). Det finns fler typer men de två används av personer utanför utvecklingsteamet för att fråga något från det.

Om du väljer namn för problemtyper låter ”bug” och ”defect” liknar mig. Skillnaden mellan dem är stilistisk. Eftersom engelska inte är mitt modersmål kan jag inte riktigt se mycket av det och jag är inte säker på om det jag ser är korrekt.