>> [Muziek]
DAVID J. MALAN: Oke.
Dit is CS50, en dit is het begin van week twee.
Dus laten we vandaag beginnen met een bug.
Een insect, is natuurlijk een fout in een programma,
en je zult zeer krijgen kent dit concept
als je nog nooit hebt geprogrammeerd voor. pset0 en nu pset1.
Maar laten we eens kijken naar iets een beetje simpel op het eerste.
Het programma hier dat ik gooide samen op voorhand,
en ik beweer dat dit moet worden afgedrukt 10 sterren op het scherm met behulp van printf,
maar het is blijkbaar buggy op een bepaalde manier.
>> Gezien het feit dat de specificatie die het moet 10 sterren af ​​te drukken,
maar het niet blijkbaar, wat zou u beweert is de bug?
Yeah?
Dus het is een uit door een fout, en wat doe je daarmee?
OK.
Excellent.
We hebben dus een gespecificeerd beginnen van nul voor i,
en we hebben een n-waarde van 10 opgegeven, maar we hebben minder dan of gelijk aan gebruikte.
De reden dat dit twee tekens en niet slechts een symbool,
als in een wiskunde boek, is dat je niet hoeft
Een manier om de een teken equivalent.
>> Dus dat betekent minder dan, maar als je begint te tellen bij nul,
maar je telt helemaal omhoog door en gelijk aan 10,
je bent natuurlijk gaat telt 11 dingen in totaal.
En dus je gaat om af te drukken 11 sterren.
Dus wat zou een oplossing voor dit zijn?
Yeah?
>> Dus gewoon aanpassen van de minder dan of gelijk aan iets minder dan zijn,
en er is, ik beweer, misschien andere oplossing ook.
Wat kan je nog doen?
Yeah?
>> Dus begin gelijk is aan 1, en reactie minder dan of gelijk aan.
En eerlijk gezegd ik zou beweren dat voor een typische menselijke,
Dit is waarschijnlijk eenvoudiger.
Beginnen te tellen bij 1 en tellen tot 10.
In wezen doen wat je bedoelt.
>> Maar de realiteit is in programmering, zoals we hebben gezien,
informatici en programmeurs over het algemeen beginnen te tellen bij nul.
En dus dat is fijn een keer je went er wel aan.
Uw conditie zal in het algemeen iets als minder dan.
Dus gewoon een logische fout die we konden nu
repareren en uiteindelijk opnieuw compileren dit en krijgen slechts 10.
>> Nou wat dacht je van deze bug hier?
Hier, nogmaals, ik beweer dat ik een doel van het afdrukken van 10 stars--
een per regel deze keer, maar het niet.
Voordat we stellen wat de oplossing is, wat dit doet
afdrukken visueel als ik compileren en run dit programma vind je ervan?
Yeah?
>> Star.
Dus alle sterren op de dezelfde lijn is wat ik heb gehoord,
en dan is de nieuwe regel.
Dus laten we proberen dat.
Dus zorg buggy-1, voer, en ik zie het gekletter commando
dat hebben we gesproken over de laatste tijd.
./buggy-1, en inderdaad zie ik alle 10 sterren op dezelfde lijn, hoewel ik claimen
in mijn specificatie slechts een reactie boven de code die ik van plan om een ​​per doen
lijn.
Maar dit ziet er goed uit.
>> Nu lijkt het lijn 15 zoals ik ben het afdrukken van een ster, en dan lijn 16
het lijkt alsof ik afdrukken een nieuwe regel karakter,
en ze zijn allebei zo ingesprongen Ik ben binnenkant van de lus duidelijk.
Dus zou ik niet ster moeten doen, nieuwe lijn, ster, nieuwe lijn, ster, nieuwe lijn?
Ja?
>> Ja, in tegenstelling tot een taal als Python, als je bekend bent,
inspringing niet belangrijk voor de computer.
Het maakt alleen de mens.
Dus terwijl ik hier heb uitgevonden lijnen 15 en 16-- dat mooi staat,
maar de computer wordt niet schelen.
De computer geeft om eigenlijk met accolades
rond deze regels code.
>> Zodat het van Clear net als in Scratch-- dat die twee regels code
worden uitgevoerd.
Als een van die gele Scratch puzzel stukken opnieuw en opnieuw en opnieuw.
>> Dus als ik nu opnieuw uit te voeren deze program-- ./buggy-2-- Hm.
Ik heb nu een fout.
Wat heb ik vergeten te doen?
Ja, dus ik heb niet compileren.
Dus zorg buggy-2.
Geen dergelijke dossier omdat ik niet de tweede versie werkelijk compileren.
Dus nu interessant zwartwerk variable-- niet 2.
We doen 1.
Maak buggy-1-- ./buggy-1-- en nu elk van hen op dezelfde lijn.
>> Nu is er een uitzondering op deze vermeende vordering van mij
die je nodig hebt deze accolades.
Wanneer is het eigenlijk OK-- als je hebt opgemerkt in paragraaf of textbooks--
aan de accolades weglaten?
Yeah?
>> Precies.
Als er maar een regel code die u
willen worden geassocieerd met de lus zoals in ons eerste voorbeeld.
Het is volstrekt legitiem aan de accolades weglaten
zoals soort gemak van de compiler om u.
Yeah?
Goede vraag.
Zou het worden beschouwd als een stijl fout?
We zouden promote-- als in CS50 stijlgids, de URL waarvoor
is pset1-- die altijd Gebruik de accolades.
Zeker als je nieuw bent bij het programmeren bent.
De realiteit is dat we niet ga u te verbieden
van het doen van deze gemakken.
Maar als je net in de swing van de dingen,
absoluut gewoon altijd gebruik maken van de krullende bretels tot je onder de knie hebt.
Goede vraag.
>> Oke.
Dus dat was toen een bug.
Tenminste in iets vrij eenvoudig.
En toch zou je dit denken is vrij rudimentair, toch?
Dit is een soort van de eerste week kijk op de taal
ziet, lees daarin uw bugs.
Maar de werkelijkheid zijn dit eigenlijk vertegenwoordiger
van een aantal behoorlijk beangstigend problemen die zich kunnen voordoen in de echte wereld.
>> Dus sommigen van jullie nog wel herinneren als je tech nieuws te volgen,
of misschien zelfs gevangen wind van deze in februari
van het afgelopen jaar dat Apple had maakte een beetje een fout in zowel iOS,
het besturingssysteem op hun telefoons, en ook
Mac OS, het besturingssysteem op hun desktops en laptops.
En je zag zulke krantenkoppen als dit.
En daarna, Apple beloofde om deze bug op te lossen,
en zeer snel deed repareren in iOS, maar dan uiteindelijk vast in Mac OS
ook.
>> Nu geen van deze krantenkoppen alleen echt onthullen wat het onderliggende probleem was,
maar de bug werd uiteindelijk teruggebracht tot een bug in SSL, Secure Sockets Layer.
En lang verhaal kort te maken, Dit is de software
dat onze browsers en andere software die wordt gebruikt om wat te doen?
>> Als ik zei dat SSL is betrokken zijn, wanneer u
een bezoek aan een URL die begint met HTTPS, wat dan zou SSL worden gerelateerd aan?
Encryptie.
Dus we praten over dit in de komende dagen.
Encryptie, de kunst van het versluiering informatie.
>> Maar lang verhaal kort te maken, Apple enige tijd geleden had een fout gemaakt
bij de uitvoering van SSL, de software die uiteindelijk implementeert
URL's zoals HTTPS of max verbindingen er ook.
Het resultaat daarvan is dat de verbindingen kon potentieel
worden onderschept.
En je connecties waren niet noodzakelijkerwijs versleuteld
als je had een aantal slechte kerel in tussen u en de bestemming website die
wist hoe om te profiteren van deze.
>> Nu Apple uiteindelijk geplaatst een fix voor dit eindelijk,
en de beschrijving van hun moeilijke situatie was dit.
Veilig transport niet valideren de authenticiteit van de verbinding.
Het probleem is verholpen door ontbrekende validatiestappen herstellen.
>> Dus dit is een zeer de hand golvende uitleg om gewoon te zeggen dat we het verknald.
Er is letterlijk een regel code die buggy was
bij de uitvoering van SSL, en als je online gaan en zoeken voor deze
je kunt eigenlijk vinden de originele broncode.
Zo, dit is een screenshot van slechts een gedeelte van een vrij groot bestand,
maar dit is een functie genaamd blijkbaar SSL verifiëren teken server key exchange.
En het duurt een stelletje argumenten en ingangen.
En we zijn niet van plan om zich te concentreren te veel op de minutia er,
maar als je je richt op de code binnen van die bovenste function-- laten
inzoomen op dat.
Je misschien al vermoedt wat de fout zou kunnen
zelfs als je geen idee hebt uiteindelijk wat u zoekt op.
Er is een soort van een anomalie hier, wat is wat?
>> Ja, ik hou er niet echt het uiterlijk van twee goto mislukt.
Eerlijk gezegd, heb ik niet echt weet wat goto mislukken middelen, maar met twee van hen
rug aan rug.
Dat wrijft me gewoon een soort van intellectueel op de verkeerde manier,
en inderdaad, als we inzoomen op alleen die lijnen, is C.
>> Dus veel van Apple's code is zelf geschreven in C,
en dit blijkbaar is echt equivalent--
niet om dat mooie inspringen versie, maar als je het feit te erkennen
dat er geen accolades, wat Apple echt schreef was code die eruit ziet
als deze.
Dus ik heb uitgezoomd en ik vastgestelde kuiltje zin
dat als er geen accolades, dat tweede goto falen dat is in het geel
gaat niet uit wat te voeren.
Het is niet geassocieerd met de als voorwaarde erboven.
>> Dus zelfs nogmaals, als je niet helemaal begrijpen wat dit zou mogelijk
moeten doen, weten dat elk van deze conditions-- elk van deze lijnen
is een zeer belangrijke stap in het controleren
Als uw gegevens is in feite versleuteld.
Dus het overslaan van een van deze stappen, niet het beste idee.
>> Maar omdat we dit tweede goto falen geel,
en omdat zodra we soort van esthetisch
verplaatsen naar links, waar het logisch is op het moment, wat
betekent dit voor de lijn van onderstaande code die tweede goto
niet zou je denken?
Het gaat altijd om te worden overgeslagen.
Dus gotos zijn over het algemeen afgekeurd om redenen die we niet echt ingaan,
en inderdaad in CS50 we de neiging niet deze verklaring goto leren,
maar je kunt denken aan goto mislukken als betekenis gaan springen
naar een ander deel van de code.
>> Met andere woorden: springen over Deze laatste regel helemaal,
en dus het resultaat van deze stomme eenvoudige fout die gewoon was
Door waarschijnlijk iemand kopiëren en er een te plakken
vaak is dat de gehele beveiliging van iOS en Mac OS
was kwetsbaar voor onderschepping door slechteriken al geruime tijd.
Totdat Apple dit uiteindelijk vastgesteld.
>> Nu, als sommige van jullie zijn eigenlijk lopen oude versies van iOS of Mac OS,
u kunt naar gotofail.com die is een website die iemand opzetten
in wezen bepalen programmatisch
als uw computer is nog steeds kwetsbaar.
En eerlijk gezegd, als het is, is het waarschijnlijk een goed idee
om uw telefoon bij te werken of je Mac op dit punt.
Maar, net testament aan hoe een appreciatie van deze lagere niveau
details en vrij eenvoudige ideeën kan echt
vertalen in beslissingen en problemen
affected-- in deze geval-- miljoenen mensen.
>> Nu een woord over de administratie.
Sectie zal komende zondag te beginnen.
U ontvangt een email met de weekend over de afdeling, op welk punt
het resectioning proces zal beginnen als je hebt
realiseerde je hebt nu een aantal nieuwe conflicten.
Dus dit gebeurt elk jaar, en we zal plaats bieden in de komende dagen.
>> Office hours-- doen houden een oog op dit schema hier.
Verandert een beetje deze week, vooral de starttijd
en de locatie, dus raadpleeg dat voordat u naar het kantoor uren
een van de volgende vier nachten.
En nu een woord op de beoordeling, vooral als je een duik nemen in probleem
stelt een en daarbuiten.
>> Dus volgens de specificatie, deze zijn algemeen
de assen waarlangs evalueren we uw werk.
Toepassingsgebied naar hetgeen mate uw code implementeert
de eigenschappen die nodig zijn door onze specificatie.
Met andere woorden, hoeveel een stuk set heb je af te bijten.
Heb je een derde van het, een helft, 100% daarvan.
Zelfs als het niet correct is, hoeveel heb je geprobeerd?
Zodat vangt het niveau van inspanning en de hoeveelheid
waaraan u beet de problemen probleem set's.
>> Correctness-- deze, naar In hoeverre is uw code
consistent met onze specificaties en vrij van bugs.
Zo werkt het goed werkt?
Als we het aantal input, doet het geven ons de output die we verwachten?
Design-- Nu is de eerste het bijzonder kwalitatieve degenen,
of degenen die het menselijk oordeel vereisen.
En inderdaad, dit is de reden waarom wij hebben een staf van zoveel Teaching Fellows en natuurlijk
assistenten.
In hoeverre is uw code goed geschreven?
>> En wederom is dit een zeer kwalitatieve beoordeling
dat op zal samen met u bi-directioneel in de komende weken.
Dus dat als je niet alleen numerieke scores, maar ook
een schriftelijke scores, of getypte feedback, of schriftelijke feedback in het Engels woorden.
Dat is wat we zullen gebruiken om u te rijden richting eigenlijk het schrijven van betere code.
En in collegezalen en sectie, zullen we proberen wijzen out-- zo vaak als we can--
wat maakt een programma niet alleen correct en functioneel goed,
maar ook goed ontworpen.
De meest efficiënte het zou kunnen zijn, of zelfs de mooiste het kan zijn.
>> Die leidt ons naar stijl.
Style uiteindelijk is een esthetisch oordeel.
Heb je een goede keuze namen voor je variabelen?
Heb je je code goed ingesprongen?
Doet het er goed uitzien, en daarom, is het gemakkelijk voor een andere persoon
te lezen van uw respectieve van de juistheid ervan.
>> Nu over het algemeen volgens de syllabus, we scoren deze dingen op een vijfpuntsschaal.
En laat me hameren huis het punt dat een drie is inderdaad goed.
Heel snel mensen gaan doen rekenen.
Als ze een drie op vijf op juistheid voor sommige pset
en ze denken damn, ik ga 60% dat in wezen een D of E.
>> Dat is niet de manier waarop we dat deze nummers.
Een drie is inderdaad goed, en wat we algemeen verwacht aan het begin
van het woord is dat als je nu op een stelletje three's-- misschien een paar
van beurzen, een paar fours-- of een paar tweeën, een paar fours--
dat is een goede plek om te beginnen.
En zolang we zien een opwaartse traject na verloop van tijd,
je bent in een bijzonder goede plek.
>> De formule die we gebruiken om gewicht wat in hoofdzaak
dit per de syllabus, die gewoon betekent dat we
meer gewicht te geven aan correctheid.
Want het is heel vaak juistheid dat kost de meeste tijd.
Geloof me nu.
U zult find-- tenminste in een pset-- dat u
besteden 90% van je tijd aan 10% van het probleem.
>> En alles soort werkt behalve een of twee bugs,
en dat zijn de bugs die houden u 's avonds laat.
Dat zijn degenen die soort ontsnappen u.
Maar na het slapen op het, of het bijwonen kantooruren
of online vragen stellen, wordt als je naar die 100% doelstelling,
en dat is waarom we het gewicht Correctheid het meest.
Ontwerp een beetje minder, en stijl een beetje minder dan dat.
Maar in mind-- stijl houden is misschien wel de makkelijkste
deze af te bijten volgens de stijlgids.
>> En nu, een meer serieuze Let op academische eerlijkheid.
CS50 heeft de ongelukkige onderscheiding van het zijn de grootste producent van Ad Board
gevallen bijna elk jaar in het verleden.
Dit is niet omdat de studenten cheat in CS50 meer nog dan een andere klasse,
maar omdat door de aard van het werk, het feit dat het elektronisch,
het feit dat we voor het kijken, en het feit dat we zijn computer wetenschappers,
Ik kan zeggen dat we helaas erg goed in het opsporen van het.
>> Dus wat betekent dit in reële termen?
Zodat het, volgens de syllabus, filosofie van de cursus
echt neer redelijk te zijn.
Er is deze lijn tussen het doen van je werk op je eigen
en het krijgen van een beetje van redelijke hulp van een vriend,
en regelrechte doen dat werk voor je vriend, of hem of haar uw code verzenden
zodat hij of zij kan gewoon nemen of lenen het uit rechts.
En dat steekt de lijn dat we getrokken in de klas.
>> Zie, de syllabus uiteindelijk voor de lijnen
dat trekken we als redelijk en onredelijk gedrag,
maar het is echt niet koken naar de essentie
van uw werk om wees dan uw eigen in het einde.
Nu met dat gezegd, er is een heuristische.
Want zoals je misschien imagine-- van kantooruren en de visuals
en de video's die we hebben getoond waardoor far-- CS50
wordt inderdaad bedoeld is als collaborative en als coöperatieve en sociale
mogelijk.
Als collaborative zoals ze nu streng.
>> Maar met dit zei, de heuristische, zoals u zult zien in de syllabus,
is dat wanneer je met een probleem.
Je hebt een aantal bug in de code die u niet kunt oplossen, is het redelijk voor u
om uw code aan iemand anders te laten zien.
Een vriend zelfs in de klas, een vriend die naast je zit op het kantoor uren,
of een lid van het personeel.
Maar ze kunnen hun code niet laten zien.
>> Met andere woorden, een antwoord op uw question--
Ik moet help-- is niet oh, hier is mijn code.
Neem een ​​kijkje op deze en afleiden uit het wat je wil.
Nu, natuurlijk, er is een manier om duidelijk te gamen
Dit systeem waarbij ik zal je laten zien mijn code voor het hebben van een vraag.
U toont mij mijn code voor het hebben van een vraag.
Maar zie de syllabus weer voor de fijnere details van waar deze lijn is.
>> Alleen maar om de foto nu te schilderen en delen zo transparant mogelijk
waar we in de afgelopen jaren, Dit is het aantal Ad Board gevallen
dat CS50 heeft meer dan gehad de afgelopen zeven jaar.
Met 14 gevallen dit meest recente daling.
In termen van de betrokken studenten, het was 20 een aantal vreemde studenten
afgelopen najaar.
Er was een piek van 33 leerlingen enkele jaren geleden.
Van wie velen zijn helaas niet meer hier op de campus.
>> Studenten betrokken als een percentage van de klasse heeft in het verleden varieerden van 0%
tot 5,3%, dat wil zeggen alleen Dit is elk jaar een uitdaging.
En naar dat einde, wat we willen doen is brengen een
dat we dd-- gewoon FYI-- vergelijken bij een fairness voor de studenten die
zijn naar aanleiding van de lijn daarvan.
Wij doen vergelijken alle huidige inzendingen tegen alle vroegere missies
van de afgelopen jaren.
>> We weten ook hoe om rond te googlen en vind code repositories
online, discussiefora online, job sites online.
Als een student het kan vinden, kunnen we zeker vind het zo veel als wij helaas.
Dus wat zie je in de syllabus al is dit spijt clausule.
Ik kan zeker waarderen, en wij allen heeft
personeel de cursus als het hebben gedaan deze, of deze zich na verloop van tijd,
zeker weet wat het is als het leven in de weg als je krijgt
sommige late night deadline-- niet alleen in deze klasse,
maar another-- als je volledig uitgeput, gestrest,
hebben een buitensporige aantal van andere dingen te doen.
Je zal op een bepaald punt in leven zeker een slechte, misschien wel te laat
nacht beslissing.
>> Dus volgens de syllabus, Er is deze clausule,
zodanig dat indien binnen 72 uur nadat enkele slechte beslissing, kunt u zich tot het
en uit te reiken naar me toe en een van de hoofden van de cursus
en wij zullen een gesprek hebben.
We zullen de dingen gaan intern in de hoop
daarvan steeds een leermoment of levensles,
en niet iets met bijzonder ingrijpende gevolgen
zoals je kunt zien op deze kaarten hier.
>> Dus dat is een heel serieuze toon.
Laten we pauzeren voor een paar seconden de spanning breken.
>> [Muziek]
>> DAVID J. MALAN: Oke, dus hoe is dat voor een segue?
Om de huidige primaire onderwerpen.
De eerste is abstractie.
Een van die gaat het worden representatie van gegevens, die eerlijk gezegd
is echt een droge manier om te zeggen hoe kunnen we gaan over het oplossen van problemen en denken
over het oplossen van problemen?
Dus je hebt gezien in de Scratch, en je hebt gezien misschien al in pset1 met C
dat je niet alleen kunt gebruiken functies zoals printf,
dat andere mensen in de afgelopen jaren schreef voor u.
U kunt ook uw eigen functies.
>> En ook al heb je misschien niet gebeurt dit in C, en eerlijk gezegd in pset1
je hoeft niet echt nodig om te schrijven van uw eigen functie omdat probleem--
terwijl misschien ontmoedigend op eerste glance-- je zult zien
kan uiteindelijk worden opgelost met niet zo veel regels code.
Maar met dat gezegd, in termen van het schrijven van uw eigen functie,
beseffen dat C geeft op u deze mogelijkheid.
>> Ik ga om te gaan in de huidige broncode, die al beschikbaar is online,
en ik ga je gang en een open gaan een programma genaamd functie 0.C,
en in functie zero we zien wel een paar dingen.
In eerste regels 18 tot en met 23 is mijn belangrijkste functie.
En nu we beginnen te lezen code dat we niet schrijven op de vlieg,
maar in plaats daarvan heb ik van tevoren schriftelijk of dat je in een probleem te stellen
mochten ontvangen hebben geschreven tevoren.
Een goed begin code te lezen van iemand anders
is op zoek naar de belangrijkste functie.
Erachter te komen waar dat item punt is het uitvoeren van het programma,
en volg het dan logisch uit daar.
>> Dus dit programma blijkbaar prints uw naam gevolgd door een dubbele punt.
Vervolgens gebruiken we GetString van de CS50 bibliotheek
om een ​​string, of een woord of zin te krijgen van de gebruiker op het toetsenbord.
En dan is er nog dit ding hier-- PrintName.
>> Nu PrintName is geen functie die wordt geleverd met een C.
Het is niet in de standaard io.h.
Het is niet in CS50.h.
Het is nogal in hetzelfde bestand.
Merken als ik naar beneden scrollen een bit-- regels 25 tot 27--
het is gewoon een mooie manier van commentaar uw code met behulp van de sterren en slashes.
Dit is een multi-lijn commentaar te leveren, en dit is slechts
mijn beschrijving in het blauw van Wat deze functie doet.
>> Omdat in lijnen 28 tot 31, Ik heb een super eenvoudige functie geschreven
wiens naam is PrintName.
Het duurt hoeveel argumenten zou je dan zeggen?
Dus een argument-- want er is een argument vermeld tussen de haakjes.
Het type dat is String.
Dat wil zeggen PrintName is als deze black box
of functie die wordt als input een string.
>> En de naam van die String gunstig zal zijn Naam.
Geen S, geen N, maar Naam.
Dus wat doet PrintName doen?
Het is leuk simpel.
Net als een regel code voor de printf, maar blijkbaar
drukt "Hallo," zo en zo.
Waar het zo en zo komt van het argument.
>> Nu is dit niet een enorme innovatie hier.
Echt, ik heb een programma dat zou kunnen genomen zijn geschreven met een regel code
door de invoering van deze hier boven, en veranderde het in iets
dat vereist een zekere zes of zeven of zo regels code helemaal hier beneden.
>> Maar het is de beoefening van een principe bekend als abstractie.
Soort inkapselen binnen een nieuw functie die een naam heeft en betere
maar die naam letterlijk zegt wat het doet.
Ik bedoel printf-- dat is niet vooral beschrijvend.
Als ik wil een maken puzzelstukje, of als ik
een functie wilt maken dat drukt de naam van iemand,
de schoonheid van dit te doen is dat ik kan eigenlijk
geven dat de functie een naam die beschrijft wat het doet.
>> Nu duurt het bij een ingang die Ik heb willekeurig genoemd naam,
maar ook dat is heerlijk beschrijvende in plaats van iets meer
generieke zoals S. En leegte, voor nu, betekent alleen
dat deze functie niet geef me terug wat dan ook.
Het is niet zoals GetString dat letterlijk geeft me terug een string
zoals we hebben gedaan met de stukjes papier met je klasgenoten van vorige week,
maar het is slechts een bijwerking.
Het drukt iets naar het scherm.
>> Dus aan het eind van de dag, als ik hoeft te maken functie-0, ./function-0,
we zullen zien, dat het vraagt ​​om mijn naam.
Ik typ David, en het typen van mijn naam.
Als ik het weer doen met Rob, het gaat om te zeggen "Hallo, Rob."
Dus een simpel idee, maar misschien extrapoleren van deze mentaal
dat als je programma's te krijgen een beetje ingewikkelder,
en je wilt een stuk van schrijven code en het gesprek dat code-- invoke
dat code-- sommige beschrijvende noemen als PrintName,
C doet veroorloven ons deze mogelijkheid.
>> Hier is nog een eenvoudig voorbeeld.
Bijvoorbeeld, als ik open een bestand van vandaag genoemd return.c,
let op wat ik hier heb gedaan.
De meeste van deze belangrijkste functie is printf.
Ik voor het eerst willekeurig initialiseren een variabele genaamd x om het nummer 2.
Vervolgens heb ik uitprinten "x is nu % I "passeren de waarde van x.
Dus ik zeg gewoon wat het is.
>> Nu ben ik gewoon vrijmoedig beweren met printf.
Ik Cubing die waarde x, en ik ben doen door te bellen naar een functie
genaamd cube passerende in x als argument,
en vervolgens het opslaan van de output in de variabele zelf, x.
Dus ik ben de oren slaat de waarde van x.
Ik ben het overschrijven van de waarde van x met wat
het resultaat van het aanroepen kubus functie.
En dan druk ik gewoon een aantal pluizige spul hier te zeggen wat ik deed.
>> Dus wat is dan kubus?
Let op wat is fundamenteel hier anders.
Ik heb de functie gegeven naam als voorheen.
Ik heb een naam die is opgegeven voor een argument.
Dit keer het heet n in plaats van de naam, maar ik kon het even wat ik wil noemen.
Maar dit is anders.
Dit ding aan de linkerkant.
Voorheen was het wat zoekwoord?
Boys.
Nu is het natuurlijk int.
>> Dus wat is misschien wel de weg te nemen?
Overwegende leegte Betekent soort niets, en dat was het geval.
PrintName teruggekeerd niets.
Het deed iets, maar hij kwam niet terug geef me
iets dat ik op het kon zetten linkerkant van een gelijkteken
zoals ik heb gedaan hier op lijn 22.
>> Dus als ik zeg in op lijn 30, wat is dat waarschijnlijk wat impliceert
over wat cube doet voor mij?
Yeah?
Het geeft een geheel.
Dus het geeft me terug, voor bijvoorbeeld een stuk papier
waarop hij het antwoord heeft geschreven.
2 blokjes, of 3 blokjes, of 4 cubed-- wat ik voorbij in,
en hoe heb ik dit te implementeren?
Nou, gewoon n keer n keer n is hoe ik een waarde zou kubus.
Dus nogmaals, super eenvoudig idee, maar demonstratief
nu hoe we kunnen functies schrijven dat eigenlijk had ons terug
waarden die van belang kunnen zijn.
>> Laten we eens kijken naar een laatste voorbeeld hier genoemd functie een.
In dit voorbeeld begint om meer dwingende krijgen.
Dus in functie is, deze program-- mededeling uiteindelijk
noemt een functie genaamd GetPositiveInt.
GetPositiveInt is geen functie in de CS50 bibliotheek
maar we besloten we zou willen dat het bestaat.
>> Dus als we naar beneden scrollen later in het bestand, merken hoe ik ging over het implementeren van
krijgen positieve int, en ik zeggen dat het meer dwingende
want dit is een behoorlijke aantal regels code.
Het is niet alleen een domme speeltje programma.
Het is eigenlijk nog wat foutcontrole en iets nuttiger te doen.
>> Dus als je niet de walkthrough heb gezien video's die we hebben ingebed in pset1,
weet dat dit een soort lus C, in dezelfde geest
naar het soort dingen Scratch kan doen.
En doe zegt dit te doen.
Print dit uit.
Dan ga je gang en krijg n-- krijgen een int en opslaan in n,
en houd deze opnieuw en opnieuw en doet opnieuw zolang n kleiner is dan een.
>> Zo n gaat minder dan een zijn alleen als de mens er niet mee.
Als hij of zij aan het typen in 0 of -1 of -50,
Deze lus gaat houden weer uitvoeren.
En uiteindelijk merk ik gewoon terug de waarde.
Dus nu hebben we een functie dat zou leuk geweest zijn
als CS50 zou implementeren in CS50.h en CS50.c voor u,
maar hier kunnen we nu uitvoering van deze onszelf.
>> Maar twee reacties op een aantal belangrijke details.
Een-- waarom heb ik verklaar int n, denk je, op lijn 29
in plaats van het doen dit hier, dat
meer in overeenstemming met wat we deden vorige week?
Yeah?
Een goede gedachte.
Dus als we waren om het te zetten hier, het is alsof we
houden opnieuw en opnieuw aangifte te doen.
Dat op zich is niet problematisch, zodanig,
want we moeten alleen de waarde een keer en dan
we gaan naar een nieuwe bemachtigen.
Maar een goede gedachte.
Yeah?
>> Sluiten.
Dus omdat ik n op heb verklaard lijn 29 buiten de lus,
het is in het hele hotel deze hele functie.
Niet de andere functies, omdat N nog binnen deze curly
bretels hier.
Dus-- zeker.
>> Precies.
Dus dit is nog meer to the point.
Als we in plaats daarvan verklaarde n hier op lijn 32,
het is problematisch omdat gok waar anders ik nodig om toegang te krijgen?
Op lijn 34, en de eenvoudige vuistregel is
dat je alleen kunt gebruik maken van een variabele binnenkant van de meest recente accolades
waarin u het verklaard.
>> Helaas, regel 34 is een regel te laat,
omdat ik al heb afgesloten de accolade op lijn 33
die overeenkomt met de accolade op lijn 30.
En dus is dit een manier om te zeggen dat deze variabele int wordt scoped,
zo te zeggen, slechts binnen van die accolades.
Het werkt gewoon niet bestaan ​​buiten hen.
>> Dus inderdaad, als ik dit doe verkeerd, laat mij de code op te slaan
als deze niet goed is-- geschreven.
Laat me gaan en weet te maken functie-1, en notice-- fout.
Het gebruik van niet-aangegeven identifier n op lijn 35, die is hier.
En als we u omhoog verder andere.
Gebruik van zwartwerk identifier n op lijn 34.
>> Dus de compiler, Clang, is te merken dat het gewoon
bestaat niet alhoewel duidelijk dat het er visueel.
Dus een eenvoudige oplossing is er aangifte te doen.
>> Laat me nu blader naar het begin van het bestand.
Wat springt uit bij u als een beetje anders
van de dingen die we gekeken naar de afgelopen week?
Niet alleen heb ik de naam niet alleen te doen Ik heb een aantal scherpe omvat tot boven,
Ik heb iets wat ik ben bellen van een prototype.
Nu dat ziet er erg vergelijkbaar met wat We zagen zojuist op lijn 27.
>> Dus laten we afleiden uit een andere foutmelding waarom ik dit heb gedaan.
Laat me gaan en daar deze lijnen te verwijderen.
En dus we weten niets over het prototype.
Remake van dit bestand.
Maak een functie.
En nu, damn, vier fouten.
Laten scrollen tot de eerste.
>> Impliciete verklaring van de functie krijgen positieve int is ongeldig in C99.
C99 betekent gewoon de 1999 versie van de taal
C, dat is wat we inderdaad gebruikt.
Dus wat betekent dit?
Goed C-- en meer specifiek C compilers-- zijn behoorlijk dom programma.
Ze weten alleen dat wat je hebt vertelde hen, en dat is
eigenlijk thematisch van vorige week.
>> Het probleem is dat als ik ga over het implementeren van de naam hier,
en ik noem een ​​functie genaamd GetPositiveInt hier op lijn 20,
die functie doet technisch niet bestaan ​​tot de compiler ziet lijn 27.
Helaas, de compiler is dingen boven, beneden, links, rechts doen,
dus omdat het niet heeft gezien de uitvoering van GetPositiveInt,
maar het ziet u probeert om het te gebruiken hier op,
het is gewoon te bail-- schreeuwen tegen u met een fout Message-- misschien
cryptische en eigenlijk het dossier samen te stellen.
>> Dus een zogenaamde prototype up Hier is weliswaar overbodig.
Letterlijk, ging ik hier en ik gekopieerd en geplakt, en ik zet het op hier.
Void zou meer goed zijn, dus we zullen letterlijk kopiëren en plakken deze keer.
Ik letterlijk gekopieerd en geplakt.
Eigenlijk net zo als een broodkruimel.
>> Een kleine aanwijzing voor de compiler.
Ik weet niet wat dit doet nog niet, maar ik ben het met de belofte om u
dat het uiteindelijk zal bestaan.
En dat is de reden waarom deze line-- in lijn 16-- eindigt met een puntkomma.
Het is overbodig door het ontwerp.
Ja?
>> Als u uw bibliotheek niet koppelen naar de-- oh, goede vraag.
Sharp is inclusief header file insluitsels.
Moet moet bijna be-- altijd aan de top
van het dossier voor een similar-- voor precies dezelfde reden, ja.
Omdat in standaard io.h is letterlijk een lijn
zoals, maar met het woord printf en met zijn argumenten en zijn terugkeer type.
En ga zo maar door het doen van scherpe behoren tot hier, wat je letterlijk doen
is het kopiëren en plakken van de inhoud van iemand anders schreef boven.
Daarbij cluing uw code in om de Dat deze functies bestaan.
Yeah?
>> Absoluut.
Dus een zeer slimme en correcte oplossing zou zijn, weet je wat?
Ik weet niet wat een prototype is, maar ik weet
Als ik begrijp dat C is gewoon stom en herdenkt boven naar beneden.
Nou laten we het wat het wil.
Snijd die code, plak het op top, en nu duw belangrijkste beneden.
Ook dit zou het probleem oplossen.
>> Maar je kon heel gemakkelijk komen met een scenario waarin A B moeten bellen,
en misschien B terugbelt naar A. Deze is iets genaamd recursie,
en zullen we hierop terugkomen.
En het wel of niet een goed ding, maar je kan zeker
breken deze oplossing.
>> En bovendien zou ik beweren stilistisch,
vooral wanneer je programma's worden deze lange en deze lange,
het is gewoon super handig boven hoofd te zetten
want het is het ding het meest programmeurs gaan schelen.
En dus is het een beetje schoner, misschien wel, om het te doen zoals
Ik deed het oorspronkelijk met een prototype zelfs
maar het ziet er een beetje redundant op het eerste gezicht.
Yeah?
Sorry, kan je het zegt luider?
>> Als u overschakelt van de locaties van de implementatie en het prototype?
Dus dat is een goede vraag.
Als u opnieuw verklaren dit neer hier, laten we eens zien wat er gebeurt.
Dus als ik dit neer Hier, je zegt.
Oh, sorry.
Luider?
Nog harder.
Oh, goede vraag.
Zou het de functie vervalt?
Je weet wel, na al die jaren, ik hebben nooit een prototype van achteraf.
Dus laten we het doen maken functie-1 daarna doen.
>> [Gemompel]
DAVID J. MALAN: Oh, wacht.
We hebben nog steeds alles opgemaakt top.
Dus laten we dit doen hier, als ik het begrijpen van uw vraag goed.
Ik zet alles, met inbegrip van het prototype bovenstaande belangrijkste,
maar ik zet het prototype onder de uitvoering.
>> Dus als ik een, krijg ik terug een error-- ongebruikte variabele n.
Oh, daar.
Dank je wel.
Laten we eens kijken, ontdoen we ons van dit.
Dat is een andere bug, dus laten we negeren dat.
Laten we dit echt snel remake.
>> OK, dus data argument niet gebruikt door de format string
n-- oh, dat komt omdat Ik veranderde deze hier.
Oke, we weten wat het antwoord gaat om-- oke, daar gaan we.
Ah, bedankt voor de positieve.
Oke, zal ik deze code te bevestigen after-- negeren deze bijzondere bug
aangezien dit was-- het werkt is het antwoord.
>> Het maakt dus niet overschrijven wat je net hebt gedaan.
Ik vermoed dat de compiler geschreven zodanig
dat het negeren van uw prototype omdat het lichaam, om zo te zeggen,
van de functie reeds geïmplementeerd hoger.
Ik zou hebben om daadwerkelijk te raadplegen de handleiding van de compiler
te begrijpen als er een andere implicatie, maar op het eerste gezicht
gewoon door te proberen en te experimenteren, er lijkt geen invloed te zijn.
Goede vraag.
>> Dus laten we nu vooruit te smeden, het verplaatsen weg van bijwerkingen die
zijn functies die iets doen als visueel op het scherm met printf,
maar geen waarde terug.
En functies die zijn terugkeer waarden zoals we net zagen een paar van.
We zagen al deze notie van omvang, en we zullen dit opnieuw en opnieuw te zien.
Maar voor nu, opnieuw, gebruik maken van de vuistregel
dat een variabele alleen kan worden gebruikt binnenkant van de meest recent geopende
en gesloten accolades als we zag in dat voorbeeld.
>> En zoals je zei, er een ability--
kon sommige van deze problemen door de invoering van een variabele wereldwijd
op de top van een bestand.
Maar in bijna alle gevallen we zouden frons op dat,
en inderdaad niet eens in die oplossing voor nu.
Dus voor nu, het afhaalrestaurant is dat variabelen hebben dit begrip scope.
>> Maar laten we nu eens kijken naar een ander droge manier daadwerkelijk kijken
op een aantal mooie interessante implementatie details.
Hoe wij informatie vertegenwoordigen.
En we al gekeken naar deze in de eerste week van de klas.
Kijkend naar binaries, en onszelf te herinneren aan decimaal.
>> Maar herinneren van vorige week dat C heeft verschillende soorten gegevens en bossen meer,
maar de meest bruikbare degenen nu misschien deze.
Een char, of karakter, dat gebeurt een byte of acht bits totaal.
En dat is om te zeggen dat de grootte van een char is slechts een byte.
Een byte is acht bits, dat betekent dus dat we kunnen vertegenwoordigen hoeveel tekens.
Hoeveel letters of symbolen op het toetsenbord
als we een byte of acht bits.
Denk terug aan week nul.
Als je acht bits, hoeveel de totale waarden
kunt u vertegenwoordigt met patronen van nullen en enen?
Een-- meer dan dat.
Dus 256 in totaal als je beginnen te tellen vanaf nul.
Dus als je acht bits-- dus als we hadden onze binaire bollen hier weer,
kunnen we schakelen de lampen en uit in een van 256 unieke patronen.
>> Nu is dit een beetje problematisch.
Niet zozeer voor het Engels en Romaanse talen, maar zeker
wanneer u voorstellen, voor Zo Aziatische talen, die
hebben veel meer symbolen dan als 26 letters van het alfabet.
We eigenlijk nodig zou kunnen meer dan een byte.
En gelukkig in de afgelopen jaren heeft de maatschappij
aangenomen andere standaarden die gebruikt meer dan een byte per lading.
>> Maar voor nu in C, de standaard is slechts een byte of acht bits.
Een integer is ondertussen vier bytes, ook bekend als 32 bits.
Wat betekent wat is het grootst mogelijke nummer kunnen we vertegenwoordigen met een int
blijkbaar?
Met een miljard.
Dus het is 4000000000 geven of te nemen.
2 bij de 32ste macht, als we aanvaarden geen negatieve getallen
en gewoon gebruik maken van alle positieve aantallen, het is 4000000000
geven of te nemen mogelijkheden.
Een vlotter is ondertussen een ander type van het type gegevens in C. Het is nog steeds een aantal,
maar het is een reëel getal.
Iets met een komma.
En het blijkt dat C maakt ook gebruik van vier bytes
om floating point waarden vertegenwoordigen.
>> Helaas hoeveel zwevende punt waarden zijn er in de wereld?
Hoeveel reële getallen zijn er?
Er is een oneindige nummer, en trouwens
Er is een oneindig aantal getallen.
Dus we zijn al soort graven zelf een gat hier.
Waarbij blijkbaar in computers-- op minste programma's geschreven in C op them--
slechts zo hoog als tellen 4000000000 geven of te nemen,
en floating point waarden kan alleen maar blijkbaar
een aantal eindige hoeveelheid precisie.
Alleen zo veel cijfers achter hun decimale punt.
>> Want natuurlijk, als je hebt slechts 32 bits,
Ik weet niet hoe we gaan om te gaan over vertegenwoordigen echte numbers-- waarschijnlijk
met verschillende patronen.
Maar er is zeker een eindige aantal van dergelijke patronen,
dus ook hier, is dit problematisch.
>> Nu kunnen we het probleem te vermijden iets.
Als u niet beschikt over een float, je kon een dubbel gebruik
in C, die u acht bytes, geeft die is veel meer mogelijke patronen van nullen
en enen.
Maar het is nog steeds eindige, die gaat problematisch te zijn als je schrijft software
voor afbeeldingen of voor chique wiskundige formules.
Dus je zou eigenlijk willen te tellen groter dan dat.
Een lange long-- dom named-- Ook acht bytes of 64 bits,
en dit is tweemaal zo lang als een int, en het is voor een lange integer waarde.
>> Fun fact-- als een int is vier bytes, hoe lang is een lange in C meestal?
Ook vier bytes, maar een lang lang is acht bytes,
en dit is om historische redenen.
>> Maar de takeaway nu is gewoon dat de gegevens heeft
in een computer-- dat is te laten vertegenwoordigen een fysiek apparaat met elektriciteit,
het is over het algemeen rijden die nullen en ones--
met eindige hoeveelheden precisie.
Dus wat is het probleem dan?
>> Nou er is een probleem van integer overflow.
Niet alleen in C, maar in computers in het algemeen.
Bijvoorbeeld, indien is een byte waard bit--
dus als dit is acht bit-- alle waarvan het nummer een.
Welk nummer is dit vertegenwoordigen als we aannemen
het is allemaal positieve waarden in binaire?
>> 255, en het is niet 256, want nul is het laagste nummer.
Dus 255 is het hoogst een, maar het probleem
is te veronderstellen dat ik wilde verhogen deze variabele die
gebruikt acht bits in totaal als ik wil om het te verhogen.
>> Nou, zodra ik een men al deze degenen,
kun je misschien bedenken visually-- gewoon zoals het dragen van de een met behulp decimals--
iets aan de hand te stromen naar links.
En inderdaad, als ik het nummer toevoegen om een, wat in binaire
is dat overloopt op nul.
>> Dus als je alleen use-- niet een int, maar een enkele byte aan getallen optellen
in een programma, door default-- zodra krijg je tot 250, 251, 252, 253, 254,
255-- 0 komt na 255, die waarschijnlijk niet wat
een gebruiker gaat verwachten.
>> Nu inmiddels in floating point wereld, ook een soortgelijk probleem.
Niet zozeer met de grootste number-- maar dat is nog steeds een probleem.
Maar de hoeveelheid precisie dat je kan vertegenwoordigen.
Dus laten we eens een kijkje nemen op dit voorbeeld ook hier van de huidige bron code--
float-0.c.
>> En merken dat het een super eenvoudig programma dat
moet blijkbaar uitprinten welke waarde?
Wat doe je inzet dit gaat om af te drukken ook al is er een beetje van de nieuwe syntaxis
hier?
Dus hopelijk 0.1.
Dus het equivalent van een tiende want ik ben bezig met 1 gedeeld door 10.
Ik ben het opslaan van het antwoord in een variabele genaamd f.
Deze variabele van het type float, die is een sleutelwoord ik net voorgesteld bestond.
>> We hebben dit niet eerder gezien, maar Dit is een soort van een nette manier in printf
aan hoeveel cijfers specificeren u willen zien na een komma.
Dus deze notatie betekent gewoon dat hier is een placeholder.
Het is voor een floating point waarde, en oh, door de manier,
het met de decimale punt met een cijfer na de komma.
Dus dat is het aantal significante cijfers,
zo te zeggen, dat je zou willen.
>> Dus laat me gaan en doen maken float-0, ./float-0,
en blijkbaar 1 gedeeld door 10 is 0.0.
Nu waarom is dit?
>> Goed weer, de computer is het nemen van me letterlijk, en ik heb geschreven 1
en ik geschreven 10, en neem een ​​gok wat is de veronderstelde gegevenstype voor die twee
waarden?
Een int, het is technisch gezien iets een beetje anders.
Het is kenmerkend een lang, maar het is uiteindelijk een integrale waarde.
Niet een floating point waarde.
>> Dat wil zeggen dat als deze is een int en dit is een int,
het probleem is dat de computer niet de mogelijkheid hebben
zelfs die komma slaan.
Dus als je dat doet 1 gedeeld met 10 behulp integers
voor zowel de teller als de deler, het antwoord zou moeten zijn 0.1.
Maar omdat de computer-- dat zijn integers--
weet niet wat te doen met de 0.1.
>> Dus wat is het duidelijk aan het doen?
Het is gewoon het weg te gooien, en wat ik zie uiteindelijk
is 0.0 alleen omdat ik erop aangedrongen dat printf toon mij een komma.
Maar het probleem is dat als u delen een geheel getal van een getal,
je zult get-- per definitie van C-- een integer.
En het is niet van plan om te doen iets wat mooi en handig
zoals rond het aan de dichtstbijzijnde omhoog of omlaag.
Het zal afkappen alles na de komma.
>> Dus gewoon intuïtief, wat is waarschijnlijk een fix?
Wat is de eenvoudigste oplossing hier?
Yeah?
Precies.
Waarom gaan we niet gewoon behandelen deze als floating point waarden effectief
draaien ze in vlotters of tweepersoonskamers.
En als ik nu doe maken praalwagens-0, of als ik compileren praalwagens-1,
die identiek is aan wat er net werd voorgesteld.
En nu doe ik praalwagens-0, nu krijg ik mijn 0.1.
>> Nu is dit geweldig.
Maar nu ga ik doen iets een beetje anders.
Ik ben benieuwd om te zien wat er echt gebeurt onder de motorkap,
en ik ga dit printen uit tot 28 cijfers achter de komma.
Ik wil echt zien 0.1000-- een infinite--
[Onverstaanbaar] 27 nullen na dat 0,1.
>> Nou laten we eens zien of dat is wat ik inderdaad krijgen.
Maak praalwagens-0 hetzelfde bestand.
./floats-0.
Laten we inzoomen op de dramatische antwoord.
Al die tijd, heb je aan het denken geweest 1 gedeeld door 10 is 10%, of 0,1.
Het is niet.
Althans wat de computer betreft.
>> Nu why-- OK, dat is compleet lie 1 gedeeld door 10 is 0,1.
Maar why-- dat is niet het afhaalrestaurant vandaag.
Dus waarom is de computer denkt, in tegenstelling tot alle van ons in de kamer,
dat 1 gedeeld door 10 is eigenlijk die gekke waarde?
Wat is de computer doet blijkbaar?
Wat is dat?
>> Het is niet overstromen, per se.
Overflow is meestal wanneer je wikkel rond een waarde.
Het is dit nummer van onnauwkeurigheid in een floating point
waar je alleen 32 of misschien zelfs 64 bit.
Maar als er een oneindige aantal echte numbers--
getallen met cijfers achter de komma en nummers thereafter-- zeker
je kunt niet alles van hen te vertegenwoordigen.
Dus de computer heeft gegeven ons die het dichtst aanleunt
de waarde kan voorstellen via dat veel bits om de waarde ik eigenlijk wil,
die 0.1.
>> Helaas, als je gaan doen wiskunde, of u
beginnen met dit soort van zwevende puntwaarden in belangrijke programs--
financiële software, militaire software-- iets
wanneer waarneming waarschijnlijk vrij belangrijk.
En u beginnen met het toevoegen nummers als deze, en start
draait die software met echt grote ingangen
of voor tal van uren of veel dagen of vele jaren,
deze kleine foutjes zeker kan oplopen in de tijd.
>> Nu nog even terzijde, als je ooit hebt gezien Superman 3 of Office Space
en je zou herinneren hoe die jongens gestolen
een hoop geld uit hun computer met drijvendekommagetallen
en het toevoegen van het kleine restanten, hopelijk die film
maakt nu meer zin.
Dit is wat ze waren zinspelend op in die film.
Het feit dat de meeste bedrijven zou niet kijken
na een aantal achter de komma,
maar dat zijn fracties van centen.
Dus je begint te tellen, je begint om veel geld te verdienen
op uw bankrekening.
Dus dat is Office Space uitgelegd.
>> Nu helaas voorbij Office Space, er
zijn enkele legitieme verontrustend en significante effecten
van dergelijke onderliggende ontwerp beslissingen,
en inderdaad een van de redenen we C gedurende
wordt, zodat je echt moet deze grond tot begrip van hoe computers werken,
hoe software werkt, en niet neem niets voor lief.
>> En inderdaad nog, zelfs met dat fundamenteel begrip,
wij mensen maken fouten.
En wat ik dacht dat ik zou delen is Dit acht minuten durende video hier genomen
van een Modern Marvels episode, die een educatieve show on hoe dingen werken
dat schildert twee foto's wanneer een oneigenlijk gebruik
en begrip van floating point waarden
genoopt tot ingrijpende ongelukkige resultaten.
Laten we eens een kijkje nemen.
[VIDEO AFSPELEN]
-We nu terug naar "engineering Rampen "op Modern Marvels.
Computers.
We hebben allen de te accepteren vaak frustrerende problemen
kreeg met them-- bugs, virussen, en software glitches-- voor kleine prijzen
betalen voor het gemak.
Maar in high tech en high speed militaire en ruimtevaart applicaties,
de kleinste probleem kan worden vergroot tot een ramp.
>> Op 4 juni 1996, wetenschappers voorbereid om een ​​onbemande Ariane 5-raket te lanceren.
Het vervoerde wetenschappelijke satellieten ontworpen
precies hoe de stand Aardmagnetische veld interageert
met zonne-wind.
De raket werd gebouwd voor het Europees Ruimte-Agentschap,
en opgestegen vanaf de faciliteit aan de kust van Frans-Guyana.
>> -at Ongeveer 37 seconden in de vlucht, ze eerst
merkte dat er iets ging verkeerd.
Dat de sproeiers waren draaibare op een manier dat ze echt niet moeten doen.
Ongeveer 40 seconden in de vlucht, duidelijk het voertuig in de problemen zat,
en dat is wanneer ze gemaakt de beslissing om het te vernietigen.
De veiligheidsfunctionaris range, met enorme lef, drukte op de knop
en blies de raket voordat het kon uitgegroeid tot een gevaar voor de openbare veiligheid.
>> -Dit was het meisje reis van de Ariane 5,
en de vernietiging nam plaats als gevolg van de fout
ingebed in de software van de raket.
-De Probleem op de Ariane was dat er
een getal dat nodig is 64 bits uit te drukken,
en ze wilden om te zetten naar een 16-bits getal.
Zij verondersteld dat het aantal was nooit erg groot te zijn.
Dat de meeste van deze cijfers de 64-bits getal waren nullen.
Ze hadden het mis.
>> -De Onvermogen van een softwareprogramma accepteren
het soort getal gegenereerd door een ander was aan de basis van de mislukking.
Software ontwikkeling was geworden van een zeer kostbaar onderdeel van de nieuwe technologie.
De Ariane 4-raket had zeer succesvol geweest.
Veel van de software gemaakt voor het werd ook gebruikt in de Ariane 5.
>> -het Basisprobleem dat was de Ariane 5.
Werd faster-- sneller versneld, en De software was niet goed voor dat.
>> -De Vernietiging van de raket was een enorme financiële ramp.
Allemaal te wijten aan een minuut softwarefout.
Maar dit was niet de eerste time data conversie problemen
had moderne rakettechnologie geplaagd.
>> -In 1991 met de start van de eerste Golfoorlog,
de Patriot raket ondervonden soortgelijke aard
een nummerconversie probleem.
En als gevolg daarvan 28 mensen-- 28 Amerikaanse soldiers-- werden gedood,
en ongeveer honderd anderen gewond.
Wanneer de Patriot, die verondersteld werd te beschermen tegen inkomende Scuds,
niet in geslaagd een raket afvuren.
>> -Wanneer Irak Koeweit binnenviel, en Amerika gelanceerd Desert Storm in het begin van 1991,
Patriot raket batterijen werden ingezet te beschermen Saoedi-Arabië en Israël
van Iraakse Scud raket aanvallen.
De Patriot is een Amerikaanse medium-range surface-to-air-systeem
vervaardigd door Raytheon bedrijf.
>> -De Grootte van de Patriot interceptor itself--
het gaat over ongeveer 20 meter lang, en hij weegt ongeveer 2.000 kilo.
En het draagt ​​een kernkop van over, Ik denk dat het ongeveer £ 150.
En de kernkop zelf is een hoog explosief, die
heeft fragmenten om hem heen.
Dus de behuizing van de kernkop is ontworpen om te fungeren als een grove hagel.
>> -De Raketten worden uitgevoerd vier per container,
en worden vervoerd door een oplegger.
>> -The Patriot anti-raket systeem gaat terug nu minstens 20 jaar.
Het werd oorspronkelijk ontworpen als luchtafweer raket
neer te schieten vijandelijke vliegtuigen.
In de eerste Golfoorlog toen die oorlog kwam op,
het leger wilde gebruiken om neer te schieten Scuds, geen vliegtuigen.
De Iraakse luchtmacht was niet zo veel van een probleem,
maar het leger was bezorgd over Scuds.
En dus probeerden ze een upgrade van de Patriot.
>> -Intercepting Een vijand raket reizen op Mach 5
zou genoeg zijn uitdagend.
Maar toen de Patriot werd in allerijl in gebruik,
het leger was zich niet bewust van een Iraakse wijziging die
maakten hun Scuds bijna onmogelijk om.
>> Wat gebeurd is, is de Scuds dat kwamen in waren instabiel.
Ze waren wiebelig.
De reden hiervoor was Iraqis-- om 600 kilometer weg te gaan
van een 300 kilometer lange range missile-- nam het gewicht van de voorste kernkop,
en maakte de kernkop lichter.
Dus nu de Patriot's proberen te komen het Scud, en de meeste tijd--
de overgrote meerderheid van de tijd-- het zou gewoon vliegen door de Scud.
>> -once De Patriot netbeheerders realiseerde de Patriot miste zijn doel,
ze ontploft de Patriot's kernkop mogelijke ongevallen of vermijden
Men liet de grond vallen.
>> Dat was wat de meeste mensen zagen als grote vuurballen in de lucht,
en verkeerd begrepen als onderschept van Scud kernkoppen.
>> -hoewel In de nachtelijke hemel, de Patriotten bleek succesvol te vernietigen
Scuds, bij Dhahran kunnen er geen misverstand over zijn prestaties.
Daar de Patriot's radarsysteem verloren spoor van een inkomende Scud
en nooit te wijten gelanceerd om een ​​software fout.
>> Het was de Israëli's die voor het eerst ontdekt dat hoe langer het systeem op,
hoe groter de tijd discrepantie werd.
Door een klok ingebed in de computer van het systeem.
>> -Ongeveer Twee weken voor de tragedie in Dhahran,
de Israëli's gemeld aan het ministerie van Defensie
dat het systeem de tijd aan het verliezen was.
Na ongeveer acht uur van het lopen, zag ze
dat het systeem van steeds aanmerkelijk minder nauwkeurig.
Het ministerie van Defensie reageerde door te vertellen al van de Patriot batterijen
niet verlaten systemen voor een lange tijd.
Ze zei nooit wat een lange tijd was.
8 uur, 10 uur, duizend uur.
Niemand wist.
>> -De Patriot batterij gestationeerd op de kazerne
bij Dhahran en zijn gebrekkige interne klok is zo'n meer dan 100 uur
Op de avond van 25 februari.
>> -Het Bijgehouden tijd met een nauwkeurigheid van ongeveer een tiende van een seconde.
Als een tiende van een seconde is een interessant getal
want het kan niet worden uitgedrukt in binaire precies die
betekent kan niet exact worden uitgedrukt in elke moderne digitale computer.
Het is moeilijk te geloven, maar Gebruik dit als een voorbeeld.
>> Laten we de nummer een derde.
Een derde kan niet worden uitgedrukt in decimale precies.
Een derde is 0.333 gaande voor oneindigheid.
Er is geen manier om dat te doen met absolute nauwkeurigheid in een decimaal.
Dat is precies het soort problemen dat gebeurde in de Patriot.
Hoe langer het systeem liep, de slechter de tijdfout werd.
>> -Na 100 uren van de werking, de fout in de tijd was slechts ongeveer een derde
seconde.
Maar in termen van zich te richten een raket reizen op Mach 5,
het resulteerde in een tracking fout van meer dan 600 meter.
Het zou een fatale fout zijn voor de soldaten aan Dhahran.
>> Wat is er gebeurd is een Scud lancering was gedetecteerd door vroegtijdige waarschuwing satellieten
en ze wisten een Scud kwam in de algemene richting.
Ze wisten niet waar het vandaan kwam.
Het was nu aan de radar component van het Patriot-systeem
verdedigen Dhahran te vinden en te houden spoor van de inkomende vijandelijke raketten.
>> -De Radar was erg slim.
Het zou eigenlijk bijhouden de positie van de Scud
en dan voorspellen waar het waarschijnlijk zou zijn
de volgende keer radar stuurde een puls uit.
Dat werd het gamma poort genoemd.
>> -Dan Zodra de Patriot beslist genoeg tijd heeft
doorgegeven om terug te gaan en controleer de volgende locatie voor dit gedetecteerde object
het gaat terug.
Dus als het ging terug naar de verkeerde plaats het dan ziet geen object.
En hij beslist dat er geen object.
Dat was er een valse detectie en het laat de baan.
>> -het Inkomende Scud verdwenen van het radarscherm,
en seconden later, sloeg in de kazerne.
De Scud gedood 28.
Het was de laatste ontslagen tijdens de eerste Golfoorlog.
Tragisch, de bijgewerkte software aangekomen in de vroege ochtend op de volgende dag.
De software fout had al vast, sluiten
een hoofdstuk in de onrustige geschiedenis van de Patriot raket.
>> [END VIDEO AFSPELEN]
>> DAVID J. MALAN: Dat is het voor CS50.
Wij zullen u op woensdag.
>> [Muziek]