Is er iets als een bugvrije applicatie? [duplicate]

Het dichtst in de buurt van een bugvrije applicatie, de duurder wordt het. Het is alsof u zich op 100% codedekking richt: u besteedt evenveel tijd en geld aan het krijgen van 0% tot 95%, van 95% tot 99% en van 99% tot 99,9%.

Heb je deze 0,1% extra codedekking of kwaliteit nodig? Waarschijnlijk wel, als je werkt aan een softwareproduct dat het koelsysteem van een kernreactor regelt. Waarschijnlijk niet als u “aan een bedrijfstoepassing werkt.

Voor het maken van hoogwaardige software is ook vereist. een heel andere benadering . Je kunt niet zomaar een team van ontwikkelaars vragen die hun hele leven zakelijke apps hebben geschreven om een bijna foutloze applicatie te maken. Voor software van hoge kwaliteit zijn verschillende technieken vereist, zoals formeel bewijs , iets wat je zeker niet wilt gebruiken in een zakelijke app, vanwege de extreem hoge kosten die het vertegenwoordigt.

Zoals ik heb uitgelegd in een van mijn artikelen :

• Zakelijke apps mogen “niet gericht zijn op de kwaliteit die vereist is voor levenskritische software, want als die zakelijke apps van tijd tot tijd falen, gebeurt dat gewoon niet” Het maakt niet uit. Ik heb bugs en downtime gezien op websites van waarschijnlijk elke grote onderneming, met Amazon als enige uitzondering. Deze downtime en die bugs zijn vervelend en kosten het bedrijf misschien enkele duizenden dollars per maand, maar het repareren ervan zou veel duurder zijn.

• De kosten zouden de primaire focus moeten zijn, en moet pragmatisch worden bestudeerd. Laten we eens kijken naar een bug die 5000 klanten treft en die zo belangrijk is dat die klanten voor altijd weggaan. Is dit belangrijk? Ja? Denk meer na. Wat als ik zeg dat elk van die klanten $ 10 per jaar betaalt en dat kostte het bijna $ 100.000 om de bug te repareren? Bugfixing ziet er nu veel minder interessant uit.

Om nu specifiek uw vragen te beantwoorden:

waarom worden bugs gerapporteerd, zelfs na zoveel testen? Is het een probleem met onze vereisten? Onze klant lijkt niet tevreden met alles wat we bieden? doen we iets verkeerd?

Er kunnen veel dingen fout gaan. Met testen bedoel je daadwerkelijk geautomatiseerd testen? Zo niet, dan is dit op zichzelf al een enorm probleem. Begrijpen testers de vereisten? Communiceert u regelmatig met de klant – ten minste één keer per iteratie, op zijn best is de vertegenwoordiger van de klant onmiddellijk ter plaatse bereikbaar voor elk lid van uw team ? Zijn uw iteraties kort genoeg? Testen ontwikkelaars hun eigen code?

Net als Ze schrijven de juiste dingen artikel waarnaar hierboven is gelinkt, neem een bugrapport en studeer waarom deze bug in de eerste plaats verscheen en waarom werd deze gemist door elke tester . Dit kan u een idee geven over de hiaten in het proces van uw team.

Een belangrijk punt om te overwegen: betaalt uw klant voor bugfixes? Zo niet, dan kan hij worden aangemoedigd om veel dingen te overwegen om een bug zijn. Door hem te laten betalen voor de tijd die u aan bugs besteedt, wordt het aantal bugrapporten aanzienlijk verminderd.

Heeft iemand een applicatie ontwikkeld die volledig bugvrij? Wat is het proces? Waarom kunnen we de applicatie niet implementeren met kleine bugs? Moeten we perfectionistisch zijn?

Ik. Ik heb het afgelopen weekend een app voor mezelf geschreven en heb tot nu toe nog geen bug gevonden.

Bugs zijn alleen bugs als ze worden gerapporteerd. Dus in theorie is het hebben van een bug-vrije applicatie heel goed mogelijk: als het door niemand wordt gebruikt, zal er niemand zijn om bugs te rapporteren.

Nu, het schrijven van een grootschalige applicatie die perfect past bij de specificatie en het is bewezen correct te zijn (zie formeel bewijs hierboven vermeld) is een ander verhaal. Als dit een levenskritisch project is, zou dit je doel moeten zijn (wat niet betekent dat je toepassing zal vrij van fouten zijn).

Is het huidige scenario het juiste ontwikkelings- en testproces? Zo niet, wat is een efficiënte manier waarop ontwikkelaars, testers en klant samen het maximale voordeel halen?

1. Om elkaar te begrijpen , ze moeten communiceren. Dit is niet wat ik heb gezien in de meeste bedrijven die ik heb gezien. In de meeste bedrijven is de projectmanager de enige die met de klant praat (soms met een vertegenwoordiger).Vervolgens deelt hij (soms gedeeltelijk) zijn begrip van de vereisten met ontwikkelaars, interactieontwerpers, architecten, DBAs en testers.

   Daarom is het essentieel voor de klant (of de vertegenwoordiger van de klant) om bereikbaar zijn voor iedereen in het team (Agile-benadering) of over formele communicatiemiddelen beschikken die een persoon autoriseren om alleen met een paar andere personen in een team te communiceren en dit op een manier te doen dat de informatie met het hele team kan worden gedeeld, ervoor zorgen dat iedereen dezelfde informatie heeft.

2. Er zijn veel ontwikkelings- en testprocessen. Zonder precies het bedrijf en het team te kennen, is er geen manier om te bepalen welke worden toegepast in uw geval. Overweeg het inhuren van een consultant of het inhuren van een projectmanager die bekwaam genoeg is.

Opmerkingen

• +1. Voordat u zelfs maar aan een project begint, moet u weten wat " goed genoeg is voor uitgave " en dienovereenkomstig te bouwen.
• @JuliaHayward Kon ' niet meer eens zijn. Het eindspel hier is niet ' t nul defecten – het produceert functionele software die tijdig waarde toevoegt.

Niet alle bugs zijn gelijk gemaakt, dus je moet het kaf van het koren scheiden.

Verwachtingen

Veel bugs worden opgeworpen door een tekortkoming in wat de software doet en wat de eindgebruiker verwacht. Deze verwachting komt uit veel gebieden: het gebruik van andere software, onjuiste documentatie, overijverig verkooppersoneel, hoe de software vroeger werkte, enz.

Scope creep

Het spreekt voor zich dat hoe meer je levert, hoe groter de kans op bugs is. Veel bugs worden eenvoudigweg naar voren gebracht op basis van nieuwe functies. Je levert X & Y maar de klant zegt dat op de achterkant hiervan het nu ook Z zou moeten doen.

Begrijp het probleemdomein

Veel bugs ontstaan om de simpele reden dat het probleemdomein slecht begrepen werd. Elke klant heeft zijn eigen bedrijfsregels, jargon en manieren om dingen te doen. Veel hiervan wordt nergens gedocumenteerd – het zit gewoon in de hoofden van mensen. Met de beste wil van de wereld kun je niet hopen dit allemaal in één keer vast te leggen.

Dus … wat te doen.

Geautomatiseerde unit tests

Veel bugs worden geïntroduceerd als een onverwacht neveneffect van een of andere codewijziging. geautomatiseerde unit-tests hebben, kunt u veel van deze problemen voorkomen en vanaf het begin betere code produceren.

Tests zijn slechts zo goed als de geleverde gegevens – dus zorg ervoor dat u het probleemdomein volledig begrijpt.

Codedekking

Dit gaat hand in hand met geautomatiseerd testen van eenheden. U zou zorg ervoor dat zoveel mogelijk code wordt getest als praktisch mogelijk is.

Leer de lessen

Madness doet steeds weer hetzelfde en verwacht andere resultaten

Begrijp je de oorzaken van de laatste mislukking? Weet je? Echt? Misschien ben je gestopt het probleem maar wat was de echte root-bron? Slechte gegevens? Gebruikersfout? Schijf corruptie? Netwerkstoring?

Niets irriteert klanten meer dan steeds dezelfde problemen tegenkomen zonder vooruitgang in de richting van een of andere vorm van oplossing.

Gebreken zijn er al vanaf het begin van de softwareontwikkeling. Het is moeilijk om aan de hand van uw vraag op te maken in hoeverre en in welke mate de defecten de bruikbaarheid of functionaliteit beïnvloeden.

Foutloze programmas bestaan, maar zowat elk niet-triviaal systeem zal defecten hebben.

U zult moeten beslissen over een soort prioriteitstelling en waarschijnlijk zult u wat onderzoek moeten doen naar de oorzaak van de defecten – waar ze werden geïntroduceerd. Er is veel te veel om over dergelijke dingen te bespreken in een eenvoudige Q & Een post.

Er zijn hele boeken geschreven over causale analyse en herstelprocessen voor een organisatie met kwaliteitsproblemen.

Dus mijn aanbeveling is: (in willekeurige volgorde)

• Implementeer een defectvolgsysteem als je er nog geen hebt gevonden
• Bepaal een manier om de ernst van defecten te classificeren
• Zoek uit waarom je niet aan de verwachtingen van de klant voldoet (zijn het de ontwikkelaars, de QA, de klant, enz.)
• Leer meer over enkele oefeningen zoals de “Vijf waarom” en doe soortgelijk onderzoek eren naar enkele van de oorzaken van uw gebreken.

Hangt af van wat je een applicatie noemt.

Als je bedoelt, een interactief programma waarbij je er zeker van moet zijn dat het real-time gedrag precies dat en dat is onder alle gegeven omstandigheden, dan is het in principe onmogelijk om te bewijzen dat er geen bugs zijn in het. Ik veronderstel dat het mogelijk zou zijn als je het stopprobleem zou kunnen oplossen, maar dat kan “t.

Als je jezelf echter beperkt tot een verklaring van “die en die invoer zal uiteindelijk die en die eindtoestand opleveren”, dan zijn je kansen op een “foutvrij bewijs” groter, omdat je invarianten unt gebruiken . Dat, en alleen dat, zorgt ervoor dat een correctheidsbewijs kan worden opgesplitst in subproblemen, waarvan elk relatief eenvoudig kan worden bewezen dat ze correct werken onder alle omstandigheden van het resterende programma (hoewel u over het algemeen “niet erg nauwkeurig kunt zijn over hoeveel tijd & geheugen het kan kosten).

Dergelijke technieken zijn in principe mogelijk in alle programmeertaal (hoewel sommige esoterische talen zoals Malbolge proberen dat te ontkrachten!), maar in alle imperatieve talen wordt het erg snel rommelig, want je moet heel veel impliciete programmastatus. In functionele talen ¹ zien de bewijzen er veel leuker uit ( zuivere talen , of de puur functionele subset van een taal). Toch zult u, met name bij dynamische typen, veel vereisten moeten opschrijven over welke invoer is toegestaan. Dat is natuurlijk een van de belangrijkste voordelen van systemen met een sterk statisch type: de vereisten staan daar in de code!
In de praktijk bevatten O “Caml- of zelfs Haskell-programmas de neiging om niet-totale functies , dwz functies die crashen / vastlopen / gooien voor bepaalde invoer, ondanks het juiste type ² . Want hoewel deze talen zeer flexibele typesystemen hebben, is het soms nog steeds niet haalbaar om het te gebruiken om iets volledig te beperken.

Voer afhankelijk getypte talen in ! Deze kunnen typen precies naar behoefte berekenen, dus alles wat u definieert, kan precies het typehandtekening hebben dat alles aantoont wat u nodig hebt. En inderdaad, talen die afhankelijk zijn getypt, worden meestal onderwezen als beproefde omgevingen . Helaas denk ik dat geen van hen echt in staat is om productiesoftware te schrijven. Voor praktische toepassingen denk ik dat het schrijven in Haskell het dichtst in de buurt komt van volledig bug-proof met zo grondig totale functies als mogelijk. Dat brengt je mooi in de buurt van bug-proof – zij het, nogmaals, alleen met betrekking tot de functionele beschrijving. Haskell De unieke manier van omgaan met IO met monaden levert ook een aantal zeer bruikbare bewijzen op, maar het vertelt je over het algemeen niets over hoe lang het duurt voordat iets af hebben. Het is heel goed mogelijk dat iets in bepaalde omstandigheden – van de POV van de gebruiker exponentiële tijd in beslag neemt, wat waarschijnlijk een net zo ernstige bug is alsof het programma volledig vastloopt.

¹ _{Of meer in het algemeen beschrijvende talen. Ik heb niet veel ervaring met logische talen, maar ik neem aan dat ze even goed kunnen bewijzen groeten.}

² _{Als het niet het juiste type is, zal de compiler het nooit toestaan in die talen; dat elimineert al veel bugs. (en, dankzij de gevolgtrekking van het Hindley-Milner-type, maakt het de programmas ook beknopter!)}

Opmerkingen

• " Als u bedoelt, een interactief programma waarbij u er zeker van moet zijn dat het real-time gedrag onder alle omstandigheden precies dat en dat is, dan is het ' s in principe onmogelijk om te bewijzen dat er geen ' bugs zijn in het. Ik veronderstel dat het mogelijk zou zijn als je het stopprobleem zou kunnen oplossen, maar je kunt ' t. ": ik weet niet zeker of dit verklaring is correct. Het is onmogelijk om een willekeurig programma te verifiëren, maar hoe zit het met een programma dat je zo hebt geschreven dat een dergelijke verificatie mogelijk is?
• Zie bijv. cs.cmu.edu/~rwh/smlbook/book.pdf , aan het begin van pagina 198: " Ten slotte is het belangrijk op te merken dat specificatie, implementatie en verificatie hand in hand gaan. Het is niet realistisch om voor te stellen om te verifiëren dat een willekeurig stuk code aan een willekeurige specificatie voldoet. Fundamentele berekenbaarheid en complexiteitsresultaten maken duidelijk dat we nooit kunnen slagen in een dergelijke onderneming. Gelukkig is het ook volledig kunstmatig. In de praktijk specificeren, coderen en verifiëren we tegelijkertijd, waarbij elke activiteit de andere informeert."
• @Giorgio: zeker dat je sommige programmas zo kunt schrijven dat een dergelijke verificatie mogelijk is, maar dat beperkt je echt behoorlijk veel. In een groot programma moet je ' bijna altijd ergens de volledigheid van Turing benutten. – Ja, in de praktijk specificeer je, codeer en " verifieer " gelijktijdig, maar die verificatie is vaak voldoende heuristisch (gebaseerd op bijvoorbeeld unit tests , geen echte bewijzen).
• Wat bedoel je met " het benutten van de volledigheid van Turing "?
• " … maar die verificatie is vaak voldoende heuristisch (gebaseerd op bijvoorbeeld eenheidstests, geen echte bewijzen) ": nee , als je de aantekeningen aandachtig leest, spreekt het over het bewijzen van juistheid door middel van formele methoden (bijvoorbeeld met behulp van inductie), het spreekt niet over unit-tests. Zie ook compcert.inria.fr/doc .