[? DAN ARMADARAS:?] Hi, Im [? Dan Armadaras?]. Vandaag gaan we kijken naar debuggen. Niet alleen gaan we praten over een aantal technieken, maar we gaan kijken naar een aantal van de functies bevatte binnen de CS50 IDE die het mogelijk maken je gemakkelijk debuggen van een programma. Een voorbeeld van iets dat mis kan gaan en het is eigenlijk iets dat we al eerder hebben gezien. In dit geval is dit een C programma dat een integer accepteert de gebruiker, volgt dat door twee, en geeft de uitgang aan de gebruiker. Nu van wat we hebben gezien eerder in lezingen, We weten dat dit daadwerkelijk zal leiden specifieke soorten divisie problemen wanneer we hebben oneven nummers. 

Concreet zullen we gewoon weggooien iets achter de komma. Nu, we weten dat dit toevallig het geval. En als we lopen, kunnen we bevestigen onze vermoedens, eerste, door het opstellen. Dan, door het uitvoeren en het invoeren van een oneven aantal. 

Dit is niets nieuws. Maar dit is eigenlijk een voorbeeld van een bug die kunnen bestaan ​​binnen een groter programma dat wordt moeilijker op te sporen. Ook al weten we wat het probleem is de ware crux zou proberen te identificeren specifiek waar de fout zich voordoet, identificeren wat dat probleem is, en vervolgens de vaststelling van het. Dus bieden dit als een voorbeeld wat zou iets zijn dat weten we al, maar kan worden begraven op andere elementen van de code. 

Dus het openen van dit andere bron codebestand als voorbeeld, deze divisie probleem is nu deel van een groter programma. Nog steeds is misschien een beetje beetje gekunsteld, en we zou gemakkelijk kunnen identificeren, met name aangezien we dit enkel bespreken. Maar we kunnen achterhalen dat dit probleem kan bestaan ​​op een grotere schaal. 

Als ik dit compileren en nu voer het uit, voer een oneven aantal, we kunnen zien dat we niet precies krijgen de uitvoer die wij hebben verwacht. In dit specifieke geval, zouden we kunnen zeggen dat we willen alle nummers te tellen van een tot een aantal specifieke nummer. En we kunnen dat we zien een verscheidenheid aan kwesties hier als we uitvoeren, gewoon, 0 en 1 wanneer wij een ingang van 5. 

Dus we weten al dat Er is hier een probleem. Maar we kunnen niet precies weten wanneer dit probleem werkelijk bestaat. Nu een van de manieren waarop we kunnen proberen om dit op te lossen is iets dat we hebben al geïntroduceerd. We kunnen gewoon gebruik maken van het op een grotere schaal. 

Op lijn 14, hebben we Dit printf functie, die ons in staat om af te drukken uit de staat van de verschillende stukjes informatie. En dit is iets dat je moet benutten binnen uw programma om te proberen om erachter te komen wat is gebeurt in verschillende regels code. Dus zelfs als dit niet het eindresultaat dat we eigenlijk willen produceren uit dit programma, we nog steeds kunnen sommige debug hebben verklaringen waar we kan proberen te achterhalen precies wat gebeurt binnenkant van onze code. 

Dus in dit geval, zal ik printf met de debug-tag. In dit geval is slechts een debug-reeks dat ik up-zetten, zodat het zeer duidelijk in de output van mijn code wat het is dat ik wil laten zien. En de output hier het aantal we hebben berekend. 

In dit geval zou ik willen precies weten wat er gebeurt en vóór na een specifieke berekening. Dus ik kan een printf gebruiken voordat en daarna regel code. In dit geval, ik kon zelfs maken het een beetje meer duidelijk door te zeggen debug vóór en debuggen na zo dat ik mezelf niet te verwarren met meerdere regels die identiek uitzien. 

Nu als we deze en run hercompileer het, voer een nummer als vijf weer, kunnen we zien dat we hebben nu uitgang voor en na en vind dat we niet hebben gedaan een duidelijke splitsing of duidelijk dat het aantal dat we eigenlijk willen doen. Nu in dit geval is niet echt een duidelijke output. Het is niet echt een duidelijke uitkomst die we willen uit van dit specifieke programma. 

Dit is wederom een beetje gekunsteld. Maar, misschien, een van de dingen die we konden doen als de specificatie zei dat we willen dit delen door 2 en voeg 1-- dus met andere woorden, We willen dan up-- afronden we zouden weten dat we konden doe dat bepaalde ding, in dit geval. Hier nu weten we dat we zullen zijn in staat om 1 toe te voegen aan onze gehalveerd nummer. 

Laten we dit opnieuw te compileren en bevestigen dat dit gedraagt ​​de manier waarop we dat willen. We kunnen nu voor dat hebben, hebben we het nummer 5. Na, hebben we de nummer 3, die volgens onze specificatie is wat we wilden doen. Maar als we kijken naar de uitgang hier, we kunnen zien dat we een ander zouden kunnen hebben bug helemaal, dat is dat we beginnen onze telling van 0. 

Nu weer, dit is iets die we hebben gezien in het verleden en we kunnen vrij gemakkelijk te repareren. Maar in dit geval, we had ook het voordeel van het gebruik van de printf statement direct in de lus weten precies waar de die fout voorkwam. Dus printf verklaringen zijn zeer nuttig bij het helpen u bepalen waar, juist in uw broncode, een specifieke fout optreedt. 

En het is ook belangrijk om te beseffen dat, als we het schrijven van code, we kunnen aannames de toestand van een programma. Of we zouden aannames over welk deel van het programma is eigenlijk juist of onjuist wanneer later als we bouwen dat programma en maakt het deel uit van een complex en groter programma dat we ons realiseren dat sommige aspecten van die eigenlijk buggy. 

Met behulp van printf kan echt helpen beperken en te identificeren de regio's van een programma dat niet mag worden precies gedraagt ​​de manier waarop we verwacht op basis van onze veronderstellingen. Maar er is ander gereedschap beschikbaar, evenals, die ons in staat om te proberen te achterhalen waar een fout optreedt en, specifiek, welke dingen gebeuren binnen het programma. 

Dus met behulp van printf is zeer handig wanneer we willen om specifieke gebieden van identificatie een programma dat enkele bug te hebben. Maar het wordt ook vervelend na een tijdje. In dit geval is dit een relatief eenvoudig programma met slechts een of twee variabelen. En wordt het heel gemakkelijk voor ons om afdruk van de waarde van die variabelen in het geheel van het programma. 

Maar we zouden een ander hebben programma dat vele variabelen. En het kan niet helemaal worden zo gemakkelijk te gebruiken printf om te proberen om te evalueren wat er gebeurt aan elk van die variabelen het programma uitvoert. Er is een programma dat bestaat genoemd debugger programma. In dit geval degene die we zullen gebruik is de GNU debugger, of GDB, dat ons toelaat om de interne inspecteren werking van een programma op een meer gedetailleerde manier. 

We kunnen daadwerkelijk uit te voeren GDB vanaf de opdrachtregel hier door simpelweg te typen GDB en de commando dat we willen debuggen. In dit geval tellen. Nu in dit geval kunnen we zien dat het brengt ons naar een prompt die GDB zegt. En we kunnen eigenlijk commando's uitvoeren om GDB daadwerkelijk starten uitvoering van de programma, stoppen op bepaalde punten, evalueren van de variabelen en inspecteren van de variabelen die bestaan ​​in de programmastatus op dat moment, enzovoort. Het geeft veel kracht voor ons. 

Maar het is gewoon zo gebeurt dat de CS50 IDE ook levert een GUI of user interface voor GDB dat stelt ons in staat om dit te doen zonder de command line interface dan ook of helemaal niet zelfs. De manier waarop ik kan toegang tot die is met behulp van de debug-toets op de top van de CS50 IDE. Nu in het verleden, wat we gezien is dat we gebruik maken van de opdracht lijn te compileren en vervolgens uitvoeren van een programma. 

De debug-knop doet beide van deze stappen. Maar het zal ook brengen de tabblad debugger uiterst rechts die ons in staat stelt om een ​​verscheidenheid te inspecteren van de eigenschappen van het programma zoals wordt uitgevoerd. Als ik klik debug, in dit geval is, zal het te brengen een nieuw tabblad in de console venster op de bodem. 

En je kunt zien dat dit tabblad heeft wat informatie aan de top. En we kunnen grotendeels negeren. Maar een van de dingen dat we willen zien dat deze luidspreker het zelfde ding dat we zou krijgen als we probeerden te lopen maken op het C-programma in het terminal-venster. 

Hier kunnen we zien het draait Clang, en heeft diverse vlaggen, en het is het samenstellen van onze count.c bestand, die het geselecteerde tabblad op dat moment was dat ik raakte debug. Dus dit is erg handig, omdat nu met behulp van deze debug-knop, kunnen we tegelijkertijd compileren en vervolgens het programma uit te voeren dat we eigenlijk wilt uitvoeren. 

Een van de vlaggen die belang, in dit geval, we hebben eigenlijk geweest met voor de langste tijd maar ook gewoon deed wat de hand zwaaien [onhoorbaar], die is dit hier. In Clang, zegt -ggdb3. In dit geval, wat we vertellen Clang, onze compiler, is dat we willen ons programma te compileren. Maar ook wat zijn genaamd symbool informatie zodat de compiler daadwerkelijk toegang veel van de onderliggende informatie vervat in het programma. 

Meer specifiek, het aantal van de functies die ik heb, de namen van deze functies, de variabelen, de types dat deze variabelen zijn, en diverse andere dingen die de debugger helpen voeren de werking ervan. Nu is er iets anders Dat is belangrijk om te vermelden als we bespreken running een programma op deze manier. 

Merk op dat het eigenlijk bracht een nieuw tabblad in onze console langs de bodem. We hoeven niet langer te interageren rechtstreeks met de terminal-venster. Maar deze nieuwe tabblad is eigenlijk een terminal venster. Het is gewoon eigen aan de lopende programma dat we hebben gecreëerd. 

Merk op dat bij de bodem, in combinatie met enkele uitgang kletteren door de compiler en de GDB, die kunnen we grotendeels negeren, het eigenlijk toont de uitvoer van ons programma op de bodem. Nu is het belangrijk om te beseffen dat dit venster eigenlijk zal u de uitvoer van je programma maar ook kan invoeren accepteren voor dat programma, ook. 

Zo bericht dat zegt Voer een getal, die dezelfde uitvoer die we hadden had in de terminal venster voordat. Maar het is nu getoond in deze nieuwe tabblad. Ik kan een nummer invoeren. En het zal in feite functie als we verwachten toont ons onze debug, output, de uitvoer die misschien buggy, zoals we eerder hebben gezien. En helemaal onderaan het heeft eigenlijk een aantal extra uitgang van het BBP gewoon te zeggen dat dit programma is voltooid. 

Nu zoals je zag in deze bijzonder lopen door, het was niet bijzonder handig omdat zelfs al hadden we de debugger menu komen up, was dit nog steeds een lopend programma. Op geen enkel moment heeft het eigenlijk pauzeren uitvoering voor ons kunnen al inspecteren de variabelen in ons systeem. Er is iets anders dat we moeten doen om om GDB krijgen om te erkennen dat we willen om de uitvoering van het programma te pauzeren en niet alleen toestaan ​​doorgaan normaal gesproken als we zouden in elk ander geval. 

Om uitvoering te pauzeren, bij een aantal specifieke lijn, we nodig hebben om te creëren wat riep een breekpunt. En een breekpunt is heel gemakkelijk gemaakt in deze CS50 IDE door het nemen van uw muis en naar links te klikken direct van enkele specifieke lijnnummer. Zodra ik dat doe, een rode stip verschijnt, wat aangeeft dat die lijn is nu een breekpunt. 

En de volgende keer dat ik run GDB, dat stopt de uitvoering op dat breekpunt wanneer dat regel code bereikt. Nu is dit een belangrijke ding om te realiseren dat het niet noodzakelijk de zo dat elke regel code in feite bereikbaar. Als ik naar een functie te creëren hier, voor example-- leegte F-- en gewoon doen een afdruk lijn hier-- hello wereld-- als ik nooit deze functie aan te roepen, Het is het geval dat, als ik een break point hier, de functie niet genoemd. En daarom, dit bijzonder breekpunt zal nooit echt pauzeren uitvoering van het programma. 

Dus laten we zeggen dat ik het goed maak een breekpunt op enkele regel code dat daadwerkelijk wordt uitgevoerd. Nu in dit geval is dat het eerste lijn in de belangrijkste functie. Zo zal het zeker het geval dat, zodra ik beginnen met de uitvoering, de eerste lijn zal worden bereikt. GDB zal uitvoering pauzeren. En dan zal ik in staat te zijn interactie met de debugger. 

U kunt meerdere regels als set breekpunten, als je zou willen. We kunnen ook een lijn te creëren up hier in dit segment van de code dat zal nooit worden bereikt. En we kunnen ook een verder hieronder. De reden dat we zouden wil dit We doen gaan in een beetje meer detail in slechts een moment. Dus voor nu, laat me gewoon uitschakelen deze extra breekpunten zodat we kunnen kijken naar wat er gebeurt als ik één break punt in mijn programma. Ik heb gedaan wat veranderingen in dit programma. Dus ik nodig om het te redden. Ik zal klikken debug, zodat ik kan beginnen met het samenstellen en vervolgens uitvoering van de debugger. 

We zullen zien dat, na momenten, de lijn die wij als de pauze gekozen punt is geel gemarkeerd. We kunnen ook merken dat er in de rechtsboven in het debug panel dat het pauzepictogram heeft gedraaid in een klein spel icoon. Dit betekent dat we pauze uitvoeren, in dit geval. En het raken van de Play-knop zou ons toelaten om de uitvoering te hervatten op dat specifieke moment. 

Merk op dat er een paar andere knoppen beschikbaar in debug paneel, ook. Stap over, die mij toelaat om voeren dat een regel code en stap over naar die lijn naar de volgende, die in dit geval, zou betekenen dat de printf instructie wordt uitgevoerd. En het zal dan pauzeren executie op lijn 13, zoals zo. 

En er is ook een stap in functie, waarin is handig als ik andere hebben gecreëerd functies elders in de broncode. En ik wil om de stap naar die functies plaats voeren die functie als geheel. Maar we zullen meer kijken naar de stap in functie in slechts een moment. Nu een aantal andere dingen die werkelijk bestaan ​​binnen deze debug panel. 

Wij hebben dit panel genaamd de noemen stack, die ons laat zien waar we precies zijn. In dit geval zijn wij binnen van de hoofdfunctie. Ons script wordt genoemd count.c. En we toevallig op te zijn lijn 13, kolom één, die is precies wat de gemarkeerde regio van de broncode aangeeft, ook. 

Nu merken dat dit toont ook onder de lokale variabele sectie alle variabelen die bestaan ​​binnen deze functie. Het is belangrijk op te merken dat alle variabelen verschijnt in deze lokale variabele sectie binnen een functie, zelfs voordat ze zijn gedefinieerd. We kunnen hier zien dat we een variabele num genaamd, heeft een standaard waarde van 0, en het is van het type int. 

Nu voordat we daadwerkelijk initialiseren al deze variabelen, we zijn niet noodzakelijkerwijs gegarandeerd een waarde van 0 te zien. En afhankelijk van andere uitvoeringen die je hebt uitgevoerd en de staat van je geheugen als je eigenlijk dit programma uitvoert, je zou kunnen vinden dat je niet de waarden van 0 niet zien en in plaats daarvan een andere gekke nummers. 

Maar maak je geen zorgen over. Het gaat niet relevant tot zijn je eigenlijk initialiseren van de waarde. Nu in dit geval, kunnen we dat zien Ik heb uitgevoerd een aantal uitgangen. En ik ben, nu, zweeg uitvoering. Maar in dit geval, wat Ik echt wil doen is nu stap over deze lijn van de code, zodat ik kan eigenlijk zoekopdracht van de gebruiker voor die int die we willen gebruiken in ons programma. 

Nu in dit geval, wanneer Ik raakte stap over, bericht dat de Pauze of liever de Resume knop is veranderd om dit pauzeknop omdat deze code daadwerkelijk uitvoert. Wat gebeurt er nu is dat het op ons te wachten voor het invoeren van een aantal gegevens zoals we kunnen zien door onze output tekst helemaal onderaan. 

Dus nu, dit is eigenlijk niet onderbroken, hoewel het, soort van, verschijnt te zijn, omdat er niets gebeurt. Maar het is gewoon zo gebeurt het dat in mijn specifieke geval op lijn 13, Ik wacht op input van de gebruiker. En dus GDB is niet in staat om te inspecteren een programma dat wordt uitgevoerd. 

Nu is de volgende keer dat ik dient een input-- dus zal ik dat nummer 5 in te voeren, zoals we hebben gezien in de past-- hit Return, en we opmerken dat, onmiddellijk, GDB pauzes en, opnieuw, wijst op de volgende regel. Maar merken dat nu, als een resultaat van onze het invoeren van een waarde, we hebben die waarde binnen bijgewerkt van onze lokale variabelen, die is zeer nuttig om precies te weten Wat dat nummer is in het geheugen. 

Nu kan ik toestaan ​​dat dit programma voort te zetten spelen totdat het einde van de uitvoering door het raken van CV. We kunnen zien dat heel snel doet het programma afwerking uitvoeren met dezelfde uitgang die we had vóór, de debugger sluit, en nu dit programma is volledig gestopt. 

I blijkt dat slechts de toepassing van zien wat gebeurt er als we daadwerkelijk getroffen hervatten. Maar we eigenlijk gaan willen terug te gaan in dit programma zodat we kunnen proberen te debuggen precies wat er gebeurt. Nu dat ik het gebruik van de debugger, kan ik niet deze debug printf verklaringen nodig. 

Dus ik kon ze te verwijderen als ik zal doen nu alleen maar om terug te gaan naar onze eenvoudiger code dat we een ogenblik geleden. Nu wanneer ik sla de programmeren en uit te voeren, zal, opnieuw naar die initiële break punt dat ik had op lijn 11. En ik zal in staat zijn om te inspecteren mijn variabelen zoals ik wil doen. 

Het is gewoon zo gebeurt het dat deze deel is niet erg interessant, En ik weet dat ik ga uit te printen deze verklaring. Vul een getal. En dan, ik weet dat ik ga de gebruiker die integer stellen. Dus misschien, ik eigenlijk wilt verplaatsen mijn break punt een beetje verder naar beneden. 

U kunt breekpunten verwijderen door te klikken op, opnieuw, direct links van die lijnnummer. Dat red dot zal verdwijnen, wat aangeeft dat breekpunt nu is verdwenen. Nu in dit geval uitvoering is onderbroken. En zo gaat het eigenlijk niet van plan om hervatten in dat geval. Maar ik kan een pauze instellen wijzen een beetje later. 

En als ik nu weer mijn code, het zal hervatten en vertel het punt van dat breekpunt. Nogmaals, ik raakte hervatten. Lijkt niet als iets gebeurt. Maar dat komt omdat mijn code wacht op invoer. Ik zal een aantal 5 in te voeren, druk op Enter, en nu de volgende breekpunt zal worden getroffen. 

Nu in dit geval is dit is de regel code dat, voordat we wisten is er gebeurd met buggy zijn. Dus laten we evalueren wat er gebeurt op dit moment. Als een regel is gemarkeerd, dit lijn nog niet is uitgevoerd. Dus in dit geval, kunnen we zien dat ik een nummer, dat Ik heb een integer genoemd num dat een waarde 5 heeft. En ik ga optreden wat wiskunde op dat nummer. 

Als ik stap over, dat we kunnen merken dat de waarde van num veranderd overeenkomstig de rekenkunde dat we eigenlijk hebben gedaan. En nu dat we binnenkant van deze lus of nu de lus zelf is gemarkeerd, we zien dat we een nieuwe variabele genaamd i die zal worden gebruikt in die lus. 

Nu herinner voordat ik gezegd dat je soms bent gaat om een ​​soort van gekke zien nummers als standaard voor dat getal of die variabele eigenlijk geïnitialiseerd. We kunnen precies zien dat Hier in deze variabele riep ik, die niet heeft Nog geïnitialiseerd op het moment van het benadrukken. Maar we kunnen zien dat het een getal dat we eigenlijk niet verwacht. 

Dat is geen probleem. Maak je geen zorgen over want we hebben niet echt geïnitialiseerd dat nummer totdat ik stap over deze lijn en de waarde i is geïnitialiseerd op de waarde 1. Dus om te zien dat dat eigenlijk het geval is, laten we stap over. We kunnen nu zien dat lijn is uitgevoerd. En we zijn nu markeren Dit printf lijn. 

En we kunnen nu zien hoe onze waarden van i en 3 zijn veranderd in de tijd. Dit is nuttig om te doen, in feite, is herhaaldelijk stap over lijnen. En je kunt wat eigenlijk vinden gebeurt binnenkant van de lus en wat gebeurt er met de variabelen binnenkant van die lus als programmauitvoering optreedt één stap tegelijk. 

Nu op dit punt, ik stapte over net genoeg dat ik nu ben aan het eind van mijn programma. Als ik stap over dat, het zal eigenlijk ophouden uitvoering zoals we hebben gezien in het verleden. Laat me opnieuw dit, wederom, dus dat ik iets anders kan wijzen, ook. 

In dit geval is me nu vraagt, wederom, een nummer dat Ik zal, nogmaals, in te voeren. Maar deze keer, ik ga in te voeren een groter aantal, zodat de lus zal herhalen keer. In dit geval, ga ik een waarde van 11 invoeren. 

Nu weer omdat ik ingesteld een breekpunt op lijn 15, het gaat om die lijn te markeren. We kunnen zien dat onze nummer 11 correct vertegenwoordigd in onze lokale variabelen. Intensivering over dat, we kunnen nu kijk wat er gebeurt in onze waarde van i als we verder binnenkant van deze lus. Het wordt opgehoogd elke keer als we bereikt de top van dat voor de lus. 

Nu is een van de dingen die zouden kunnen nuttig zijn tijdens uitvoering van dit programma is voor mij eigenlijk veranderen de variabelen midstream te zien wat gebeurt er met mijn programma. In dit geval, kan ik eigenlijk Dubbelklik op de waarde. Merk op dat het een tekstveld. 

Nu kan ik anders in te voeren waardeert totaal om te zien hoe mijn programma gedraagt als ik die variabele ben veranderd. Nu in dit geval de variabele i bevat nu de waarde 10. Maar het programma is nog steeds gepauzeerd in de uitvoering. Toen ik stap over, zie ik dat de waarde i, die ik ingevoerd als 10, niet groter is dan de waarde van num, waardoor meteen de lus stoppen uitvoeren. 

Nu is dat niet de enige reden waarom je zou willen de variabele in de plaats te wijzigen. Je zou eigenlijk willen om te proberen om het zo te wijzigen dat u kunt blijven uitvoeren van een lus of zo, dat u kunt wijzigen zekere waarde vóór een aantal specifieke set van rekenkundige bereikt dat je op het punt om uit te voeren. 

Dus nu dat we eigenlijk veranderen waarde van i het programma werd uitgevoerd, het veroorzaakt de lus te stoppen voortijdig want ineens, i toevallig groter is dan de waarde van num, wat betekent dat voor de lus niet meer nodig te worden uitgevoerd. Verder is er gebeurd met de te Indien we veranderde de waarde van i als de lijn 17 werd benadrukt, welke het tijdstip was dat de voor de uitvoering lus eigenlijk geëvalueerd. 

Als ik de waarde van was veranderd ik op een andere lijn, zeggen 19, zouden we anders hebben gezien gedrag omdat de lijn 19 zou hebben uitgevoerd voordat de lus voorwaarde werd opnieuw geëvalueerd. Nu op dit punt, ik ben, nogmaals, Aan het einde van het programma. En ik kan toestaan ​​dat deze over te gaan tot toestaan ​​dat mijn programma op natuurlijke wijze af te sluiten. Maar er zijn een paar dingen die belangrijk zijn om mee te nemen zijn van deze bijzondere discussie. Je nodig hebt om te evalueren je eigen aannames over hoe de code moet worden gedragen. Elke keer als je denkt dat een stukje code weet je toevallig aan het werk, dat een rode vlag te gaan zou kunnen zijn rug en te evalueren, en zorg ervoor dat dat uw aanname van hoe die code werkt is eigenlijk waar de manier waarop het is uitgedrukt in uw broncode. 

Maar nog meer punt was, wanneer we met behulp van de debugger, U kunt breekpunten op te zetten verschillende regels code, die de debugger te veroorzaken pauzeren uitvoering op elk van die lijnen zodat u kunt evalueren geheugen of zelfs veranderen in de plaats. En nogmaals, vergeet niet dat je kunt creëren van meerdere breekpunten, zodat u kan ook worden hervat uitvoering, skip over grote delen van de code, en het zal automatisch pauzeren bij de volgende breekpunt. 

Er is eigenlijk meer geavanceerde kenmerken van de debugger, ook. Maar we moeten u verwijzen wat latere video om echt te plagen elkaar hoe die specifieke functies. Voor nu, dank u heel erg voor het kijken. En veel geluk debuggen.