"Ik wit dat ik neat wit," Sokrates
Foar wa: foar IT-minsken dy't spuie op alle ûntwikkelders en wolle spylje harren spultsjes!
Wêroer: hoe begjinne te skriuwen spultsjes yn C / C ++ as jo nedich hawwe!
Wêrom moatte jo dit lêze: App-ûntwikkeling is net myn wurkspesjaliteit, mar ik besykje elke wike te koade. Om't ik hâld fan spultsjes!
Goeie myn namme is , Ik bin in DevOps by Luxoft. Applikaasjeûntwikkeling is net myn wurkspesjaliteit, mar ik besykje elke wike te koade. Om't ik hâld fan spultsjes!
De yndustry foar kompjûterspultsjes is enoarm, hjoed noch mear geroften dan de filmindustry. Spultsjes binne skreaun sûnt it begjin fan kompjûters, mei help fan, troch moderne noarmen, komplekse en basis ûntwikkeling metoaden. Yn 'e rin fan' e tiid begon spielmotoren te ferskinen mei al programmearre grafiken, natuerkunde en lûd. Se kinne jo rjochtsje op 'e ûntwikkeling fan it spultsje sels en net lestich falle oer syn stifting. Mar tegearre mei harren, mei de motoren, de ûntwikkelders "gean blyn" en degradearje. De hiele produksje fan spultsjes wurdt op 'e cunewalde set. En de kwantiteit fan produksje begjint te hearskjen oer syn kwaliteit.
Tagelyk, by it spieljen fan spultsjes fan oare minsken, wurde wy konstant beheind troch lokaasjes, plot, karakters, spielmeganika wêrmei't oare minsken kamen. Dat ik realisearre dat ...
... it is tiid om jo eigen wrâlden te meitsjen, allinich foar my. Wrâlden dêr't ik de Heit en de Soan en de Hillige Geast bin!
En ik leau oprjocht dat troch it skriuwen fan jo eigen spultsje motor en in spultsje derop, do silst wêze kinne om te iepenjen dyn eagen, wipe de finsters en pomp dyn kabine, wurden in mear betûfte en yntegraal programmeur.
Yn dit artikel sil ik besykje jo te fertellen hoe't ik begon lytse spultsjes te skriuwen yn C / C ++, wat is it ûntwikkelingsproses en wêr't ik tiid fyn foar in hobby yn in drokke omjouwing. It is subjektyf en beskriuwt it proses fan in yndividuele start. Materiaal oer ûnwittendheid en leauwen, oer myn persoanlike byld fan 'e wrâld op dit stuit. Mei oare wurden, "De administraasje is net ferantwurdlik foar jo persoanlike harsens!".
Praktyk
"Kennis sûnder praktyk is nutteloos, praktyk sûnder kennis is gefaarlik." Confucius
Myn notebook is myn libben!
Dus yn 'e praktyk kin ik sizze dat alles foar my begjint mei in notebook. Ik skriuw dêr net allinnich myn deistige taken op, mar ek tekenje, programmearje, ûntwerpe flowcharts en los problemen op, ynklusyf wiskundige. Brûk altyd in notepad en skriuw allinich mei in potlead. It is skjin, noflik en betrouber, IMHO.
Myn (al fol) notebook. Dit is hoe't it derút sjocht. It befettet deistige taken, ideeën, tekeningen, diagrammen, oplossings, swarte boekhâlding, koade, ensfh.
Op dit poadium slagge it my om trije projekten te foltôgjen (dit is yn myn begryp fan "finaliteit", om't elk produkt relatyf einleaze kin wurde ûntwikkele).
- Projekt 0: dit is in Architect Demo 3D-sêne skreaun yn C # mei de Unity-spielmotor. Foar macOS en Windows platfoarms.
- Spultsje 1: console game Simple Snake (bekend foar elkenien as "Snake") foar Windows. skreaun yn C.
- Spultsje 2: console game Crazy Tanks (by elkenien bekend as "Tanks"), al skreaun yn C ++ (mei klassen) en ek ûnder Windows.
Projekt 0 Arsjitekt Demo
- Perron: Windows (Windows 7, 10), Mac OS (OS X El Capitan v. 10.11.6)
- Taal: C#
- Spultsjemotor:
- Ynspiraasje:
- Repository:
3D Scene Architect Demo
It earste projekt waard útfierd net yn C / C ++, mar yn C # mei help fan de Unity game motor. Dizze motor wie net sa easken op hardware as , en like my ek makliker te ynstallearjen en te brûken. Ik haw gjin oare motoren beskôge.
It doel yn Unity foar my wie net om in soarte fan spultsje te ûntwikkeljen. Ik woe in 3D-sêne meitsje mei in soarte fan karakter. Hy, of leaver Sy (ik modele it famke dêr't ik fereale op wie =) moast ferhúzje en omgean mei de bûtenwrâld. It wie allinich wichtich om te begripen wat Unity is, wat it ûntwikkelingsproses is, en hoefolle muoite it kostet om wat te meitsjen. Dit is hoe't it Arsjitekt Demo-projekt waard berne (de namme waard útfûn hast út 'e bullshit). Programming, modellering, animaasje, texturing namen my wierskynlik twa moanne deistich wurk.
Ik begon mei tutorialfideo's op YouTube oer hoe't jo 3D-modellen kinne meitsje yn . Blender is in geweldich fergese ark foar 3D-modellering (en mear) dat gjin ynstallaasje fereasket. En hjir wachte my in skok ... It docht bliken dat modellering, animaasje, tekstuering enoarme aparte ûnderwerpen binne wêrop jo boeken kinne skriuwe. Dit jildt benammen foar de karakters. Om fingers, tosken, eagen en oare dielen fan it lichem te modellearjen, sille jo kennis fan anatomy nedich hawwe. Hoe binne de spieren fan it gesicht ynrjochte? Hoe bewegen minsken? Ik moast bonken "ynfoegje" yn elke earm, skonk, finger, knibbels!
Model de klavikel, ekstra bonke levers, sadat de animaasje der natuerlik útsjocht. Nei sokke lessen realisearje jo wat in enoarm wurk de makkers fan animearre films dogge, gewoan om 30 sekonden fideo te meitsjen. Mar 3D-films duorje oeren! En dan komme wy de bioskoop út en sizze soksawat as: “Ta, in shitty cartoon/film! Se koenen better dien hawwe ..." Dwazen!
En noch ien ding oer programmearring yn dit projekt. As it die bliken, wie it meast nijsgjirrige diel foar my it wiskundige. As jo it toaniel útfiere (keppeling nei it repository yn 'e projektbeskriuwing), sille jo merke dat de kamera om it famkeskarakter draait yn in sfear. Om sa'n kamera-rotaasje te programmearjen, moast ik earst de koördinaten fan it posysjepunt op 'e sirkel (2D), en dan op' e bol (3D) berekkenje. It grappige is dat ik op skoalle in hekel oan wiskunde hie en it mei in min wist. Foar in part, wierskynlik, om't se jo op skoalle gewoan net útlizze hoe't dizze wiskunde yn it libben tapast wurdt. Mar as jo obsedearre binne mei jo doel, dream, dan wurdt de geast dúdlik, iepenbiere! En jo begjinne komplekse taken as in spannend aventoer te sjen. En dan tinke jo: "No, wêrom koe *leafde* wiskundige normaal net fertelle wêr't dizze formules oanlein wurde kinne?".
Berekkening fan formules foar it berekkenjen fan de koördinaten fan in punt op in sirkel en op in bol (fan myn notebook)
Wedstriid 1
- Perron: Windows (test op Windows 7, 10)
- Taal: Ik tink dat it skreaun is yn suver C
- Spultsjemotor: Windows konsole
- Ynspiraasje:
- Repository:
Ienfâldich Snake-spiel
De 3D-sêne is gjin spultsje. Derneist is it modellearjen en animearjen fan 3D-objekten (benammen karakters) lang en dreech. Nei it boartsjen mei Unity, realisearre ik dat ik moast trochgean, of leaver begjinne, fan de basis. Iets ienfâldich en fluch, mar tagelyk globaal, om de struktuer fan spultsjes te begripen.
En wat hawwe wy ienfâldich en fluch? Dat is rjocht, konsole en 2D. Mear krekter, sels de konsole en symboalen. Nochris begon ik te sykjen nei ynspiraasje op it ynternet (yn 't algemien beskôgje ik it ynternet as de meast revolúsjonêre en gefaarlike útfining fan' e XNUMXe ieu). Ik groeven in fideo fan ien programmeur dy't makke konsole Tetris. En yn 'e likenis fan syn spultsje besleat hy de "slang" ôf te snijen. Fan 'e fideo learde ik oer twa fûnemintele dingen - de spiellus (mei trije basisfunksjes / dielen) en útfier nei de buffer.
De spielloop kin der sa útsjen:
int main()
{
Setup();
// a game loop
while (!quit)
{
Input();
Logic();
Draw();
Sleep(gameSpeed); // game timing
}
return 0;
}De koade presintearret de hiele haadfunksje () tagelyk. En de spultsje syklus begjint nei de oerienkommende opmerking. D'r binne trije basisfunksjes yn 'e lus: Input (), Logic (), Draw (). Earst, ynfier gegevens Input (benammen kontrôle fan toetsoanslaggen), dan ferwurkjen de ynfierde gegevens Logic, dan werjaan op it skerm - Draw. En dus elk frame. Animaasje wurdt makke op dizze manier. It is as cartoons. Normaal nimt it ferwurkjen fan de ynfiergegevens de measte tiid en bepaalt, foar safier't ik wit, de framerate fan it spul. Mar hjir is de Logic () funksje hiel fluch. Dêrom moat de frame rate wurde regele troch de Sleep () funksje mei de gameSpeed parameter, dy't dizze taryf bepaalt.
spultsje syklus. Snake-programmearring yn notepad
As jo in symboalysk konsolespul ûntwikkelje, dan sil it werjaan fan gegevens op it skerm mei de gewoane streamútfier 'cout' net wurkje - it is heul stadich. Dêrom moat de útfier wurde útfierd yn 'e skermbuffer. Sa folle flugger en it spultsje sil wurkje sûnder glitches. Om earlik te wêzen, begryp ik net hielendal wat in skermbuffer is en hoe't it wurket. Mar ik sil hjir in koadefoarbyld jaan, en miskien kin ien yn 'e kommentaren de situaasje dúdlik meitsje.
De skermbuffer krije (as ik it sizze mei):
// create screen buffer for drawings
HANDLE hConsole = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE, 0,
NULL, CONSOLE_TEXTMODE_BUFFER, NULL);
DWORD dwBytesWritten = 0;
SetConsoleActiveScreenBuffer(hConsole);Direkte útfier nei it skerm fan in bepaalde line scoreLine (de rigel foar it werjaan fan skoares):
// draw the score
WriteConsoleOutputCharacter(hConsole, scoreLine, GAME_WIDTH, {2,3}, &dwBytesWritten);Yn teory, der is neat yngewikkeld yn dit spul, it liket my in goed foarbyld fan in yngong-nivo spultsje. De koade is skreaun yn ien triem en arranzjearre yn ferskate funksjes. Gjin klassen, gjin erfskip. Jo kinne sels alles sjen yn 'e boarnekoade fan it spul troch te gean nei it repository op GitHub.
Game 2 Crazy Tanks
- Perron: Windows (test op Windows 7, 10)
- Taal: C ++
- Spultsjemotor: Windows konsole
- Ynspiraasje: in boek
- Repository:
Crazy Tanks spultsje
It printsjen fan karakters nei de konsole is wierskynlik it ienfâldichste ding dat jo kinne omsette yn in spultsje. Mar dan komt der ien probleem op: de personaazjes hawwe ferskillende hichten en breedtes (de hichte is grutter as de breedte). Sa sil alles net evenredich lykje, en omleech of omheech sil folle flugger lykje as nei lofts of rjochts. Dit effekt is heul merkber yn "Snake" (Game 1). "Tanks" (Game 2) hawwe net sa'n nadeel, sûnt de útfier dêr wurdt organisearre troch it skilderjen fan it skerm piksels mei ferskillende kleuren. Jo kinne sizze dat ik in renderer skreau. Wier, dit is al wat yngewikkelder, hoewol folle nijsgjirriger.
Foar dit spultsje sil it genôch wêze om myn systeem te beskriuwen foar it werjaan fan piksels op it skerm. Ik tink dat dit is it wichtichste part fan it spul. En al it oare kinne jo sels betinke.
Dat, wat jo op it skerm sjogge is gewoan in set fan bewegende kleurde rjochthoeken.
Rjochthoeke set
Elke rjochthoek wurdt fertsjintwurdige troch in matrix fol mei nûmers. Trouwens, ik kin ien nijsgjirrige nuânse markearje - alle matriksen yn it spultsje binne programmearre as in iendiminsjonale array. Net twadiminsjonaal, mar iendiminsjonaal! Iendiminsjonale arrays binne folle makliker en flugger om mei te wurkjen.
In foarbyld fan in spultsje tank matrix
Fertsjintwurdigje de Matrix fan in Game Tank mei in Ien-Dimensional Array
In mear yllustratyf foarbyld fan in matrixfoarstelling troch in iendiminsjonale array
Mar tagong ta de eleminten fan de rige komt foar yn in dûbele lus, as wie it net in ien-diminsjonale, mar in twadiminsjonale rige. Dit wurdt dien om't wy noch mei matriksen wurkje.
Trochgean fan in iendiminsjonale array yn in dûbele lus. Y is de rige ID, X is de kolom ID
Tink derom dat ik ynstee fan 'e gewoane matrixidentifikatoren i, j, de identifiers x en y brûke. Dus, liket my, nofliker foar it each en dúdliker foar it brein. Dêrnjonken makket sa'n notaasje it mooglik om de brûkte matriks maklik te projektearjen op 'e koördinaatassen fan in twadiminsjonaal byld.
No oer piksels, kleur en werjefte. De StretchDIBits-funksje (Header: windows.h; Bibleteek: gdi32.lib) wurdt brûkt foar útfier. Under oare dingen wurdt it folgjende trochjûn oan dizze funksje: it apparaat wêrop de ôfbylding wurdt werjûn (yn myn gefal is dit de Windows-konsole), de koördinaten fan it begjin fan it werjaan fan de ôfbylding, syn breedte / hichte, en de ôfbylding sels yn 'e foarm fan in bitmap (bitmap), fertsjintwurdige troch in array fan bytes. Bitmap as in array fan bytes!
De StretchDIBits() funksje oan it wurk:
// screen output for game field
StretchDIBits(
deviceContext,
OFFSET_LEFT, OFFSET_TOP,
PMATRIX_WIDTH, PMATRIX_HEIGHT,
0, 0,
PMATRIX_WIDTH, PMATRIX_HEIGHT,
m_p_bitmapMemory, &bitmapInfo,
DIB_RGB_COLORS,
SRCCOPY
);Unthâld wurdt tawiisd foarôf foar dizze bitmap mei help fan de VirtualAlloc () funksje. Dat is, it fereaske oantal bytes is reservearre om ynformaasje oer alle piksels op te slaan, dy't dan op it skerm werjûn wurde.
In m_p_bitmapMemory bitmap oanmeitsje:
// create bitmap
int bitmapMemorySize = (PMATRIX_WIDTH * PMATRIX_HEIGHT) * BYTES_PER_PIXEL;
void* m_p_bitmapMemory = VirtualAlloc(0, bitmapMemorySize, MEM_COMMIT, PAGE_READWRITE);Rûchwei sprutsen, in bitmap bestiet út in set fan piksels. Elke fjouwer bytes yn 'e array is in RGB-piksel. Ien byte per reade wearde, ien byte per griene wearde (G), en ien byte per blauwe kleur (B). Plus, d'r is ien byte per ynspring. Dizze trije kleuren - Reade / Grien / Blau (RGB) - wurde mingd mei elkoar yn ferskate ferhâldingen - en de resultearjende pikselkleur wurdt krigen.
No, wer, elke rjochthoek, as spultsje foarwerp, wurdt fertsjintwurdige troch in nûmer matrix. Al dizze spultsje objekten wurde pleatst yn in kolleksje. En dan wurde se op it spylfjild pleatst, en foarmje ien grutte numerike matrix. Ik yn kaart brocht elk nûmer yn 'e matrix nei in spesifike kleur. Bygelyks, it nûmer 8 is blau, it nûmer 9 is giel, it nûmer 10 is donkergriis, ensfh. Sa kinne wy sizze dat wy hawwe in matrix fan it spylfjild, dêr't elk nûmer is in soarte fan kleur.
Dat, wy hawwe in numerike matrix fan it hiele spylfjild oan 'e iene kant en in bitmap foar it werjaan fan de ôfbylding oan' e oare. Oant no is de bitmap "leech" - it hat noch gjin ynformaasje oer de piksels fan 'e winske kleur. Dit betsjut dat de lêste stap de bitmap sil folje mei ynformaasje oer elke piksel basearre op de numerike matrix fan it spylfjild. In yllustratyf foarbyld fan sa'n transformaasje is yn 'e foto hjirûnder.
In foarbyld fan it ynfoljen fan in bitmap (Pixel matrix) mei ynformaasje basearre op de numerike matrix (Digitale matrix) fan it spielfjild (kleur-yndeksen komme net oerien mei de yndeksen yn it spul)
Ik sil ek presintearje in stik echte koade út it spul. De fariabele colorIndex by elke iteraasje fan de loop wurdt tawiisd in wearde (kleur yndeks) út de numerike matrix fan it spylfjild (mainDigitalMatrix). Dan wurdt de kleur sels skreaun nei de kleurfariabele basearre op de yndeks. Fierder is de resultearjende kleur ferdield yn 'e ferhâlding fan read, grien en blau (RGB). En tegearre mei de ynspring (pixelPadding) wurdt dizze ynformaasje hieltyd wer skreaun nei de piksel, en foarmje in kleurôfbylding yn 'e bitmap.
De koade brûkt oanwizers en bitwize operaasjes, dat kin lestich te begripen. Dat ik ried jo oan om earne apart te lêzen hoe't sokke struktueren wurkje.
In bitmap ynfolje mei ynformaasje basearre op de numerike matrix fan it spylfjild:
// set pixel map variables
int colorIndex;
COLORREF color;
int pitch;
uint8_t* p_row;
// arrange pixels for game field
pitch = PMATRIX_WIDTH * BYTES_PER_PIXEL; // row size in bytes
p_row = (uint8_t*)m_p_bitmapMemory; //cast to uint8 for valid pointer arithmetic
(to add by 1 byte (8 bits) at a time)
for (int y = 0; y < PMATRIX_HEIGHT; ++y)
{
uint32_t* p_pixel = (uint32_t*)p_row;
for (int x = 0; x < PMATRIX_WIDTH; ++x)
{
colorIndex = mainDigitalMatrix[y * PMATRIX_WIDTH + x];
color = Utils::GetColor(colorIndex);
uint8_t blue = GetBValue(color);
uint8_t green = GetGValue(color);
uint8_t red = GetRValue(color);
uint8_t pixelPadding = 0;
*p_pixel = ((pixelPadding << 24) | (red << 16) | (green << 8) | blue);
++p_pixel;
}
p_row += pitch;
}Neffens de hjirboppe beskreaune metoade wurdt ien foto (frame) foarme yn it spultsje Crazy Tanks en werjûn op it skerm yn 'e Draw () -funksje. Nei't registrearre toetsoanslaggen yn de ynfier () funksje en harren dêropfolgjende ferwurking yn de Logic () funksje, in nije foto (frame) foarme. Wier, spulobjekten kinne al in oare posysje hawwe op it spylfjild en wurde dêrtroch op in oar plak tekene. Dit is hoe't animaasje (beweging) bart.
Yn teory (as jo neat fergetten hawwe), is it begripen fan it spultsje fan 'e earste wedstriid ("Snake") en it systeem foar it werjaan fan piksels op it skerm fan 'e twadde wedstriid ("Tanks") alles wat jo nedich hawwe om ien fan jo 2D-spultsjes foar Windows te skriuwen. Geluidleas! 😉 De rest fan de dielen binne gewoan in flecht fan fancy.
Fansels is it spultsje "Tanks" folle yngewikkelder ûntwurpen dan de "Snake". Ik haw al brûkt de C ++ taal, dat is, ik beskreau ferskate spultsje objekten mei klassen. Ik makke myn eigen kolleksje - jo kinne sjen de koade yn headers / Box.h. Trouwens, de kolleksje hat wierskynlik in ûnthâldlek. Brûkte oanwizers. Wurke mei ûnthâld. Ik moat sizze dat it boek my in protte holpen hat. Begjinne C ++ Troch Game Programming. Dit is in geweldige start foar begjinners yn C ++. It is lyts, nijsgjirrich en goed organisearre.
It duorre sawat seis moannen om dit spultsje te ûntwikkeljen. Ik skreau benammen tidens lunch en snacks op it wurk. Hy siet yn 'e kantoarkeuken, stapte op iten en skreau koade. Of thús foar it iten. Dat ik krige sokke "keukenoarloggen". Lykas altyd haw ik in notebook aktyf brûkt, en alle konseptuele dingen binne deryn berne.
Oan 'e ein fan it praktyske diel sil ik in pear scans fan myn notebook útlûke. Om sjen te litten wat ik krekt oan it skriuwen wie, tekene, telde, ûntwerpe ...
Tank ôfbylding ûntwerp. En de definysje fan hoefolle piksels elke tank moat besette op it skerm
Berekkening fan it algoritme en formules foar de rotaasje fan 'e tank om syn as
Diagram fan myn kolleksje (dyjinge mei it ûnthâldlek, wierskynlik). De kolleksje wurdt makke as in keppele list
En dit binne futile besykjen om keunstmjittige yntelliginsje yn it spul te skroefjen
Teory
"Sels in reis fan tûzen kilometer begjint mei de earste stap" (Alde Sineeske wiisheid)
Litte wy fan praktyk nei teory gean! Hoe fine jo tiid foar jo hobby?
- Bepale wat jo echt wolle (och, dit is it dreechste).
- Stel prioriteiten.
- Offer alle "oerstallige" om 'e wille fan hegere prioriteiten.
- Bewege elke dei nei jo doelen.
- Ferwachtsje net dat der twa of trije oeren frije tiid wêze sil foar in hobby.
Oan 'e iene kant moatte jo bepale wat jo wolle en prioritearje. Oan 'e oare kant is it mooglik om guon gefallen / projekten te ferlitten yn it foardiel fan dizze prioriteiten. Mei oare wurden, jo moatte alles "oerstallich" opofferje. Ik hearde earne dat der yn it libben maksimaal trije haadaktiviteiten wêze moatte. Dan kinne jo op 'e bêste manier mei har omgean. En ekstra projekten / rjochtingen sille begjinne te oerladen corny. Mar dit is allegear, wierskynlik, subjektyf en yndividueel.
D'r is in bepaalde gouden regel: haw noait in dei fan 0%! Ik learde deroer yn in artikel fan in indie-ûntwikkelder. As jo oan in projekt wurkje, doch der dan alle dagen wat oan. En it makket net út hoefolle jo meitsje. Skriuw ien wurd of ien rigel koade, besjoch ien tutorialfideo, of hammer ien spiker yn it boerd - doch gewoan wat. It dreechste diel is om te begjinnen. As jo ienris begjinne, sille jo wierskynlik in bytsje mear dwaan dan jo woene. Dat jo sille konstant nei jo doel bewegen en, leau my, heul fluch. Ommers, de wichtichste rem op alle dingen is útstel.
En it is wichtich om te betinken dat jo it frije "zaagsel" fan 'e tiid yn 5, 10, 15 minuten net moatte ûnderskatte en negearje, wachtsje op guon grutte "logs" dy't in oere of twa duorje. Steansto yn de rige? Tink oer wat foar jo projekt. Giest de roltrap op? Skriuw wat yn in notebook. Yste jo yn 'e bus? Okee, lês wat artikel. Brûk elke kâns. Stopje mei it sjen fan katten en hûnen op YouTube! Ferjit net mei jo harsens!
En de lêste. As jo, nei it lêzen fan dit artikel, it idee leuk fine om spultsjes te meitsjen sûnder spielmotoren te brûken, tink dan oan de namme Casey Muratori. Dizze keardel hat . Yn 'e seksje "watch -> FOARIGE EPISODES" sille jo geweldige fergese fideotutorials fine oer hoe't jo in profesjoneel spultsje fanôf it begjin kinne meitsje. Yn fiif lessen fan Intro nei C foar Windows kinne jo mear leare dan yn fiif jier stúdzje oan 'e universiteit (ien skreau hjiroer yn' e opmerkings ûnder de fideo).
Casey ferklearret ek dat jo troch jo eigen spielmotor te ûntwikkeljen, jo in better begryp sille hawwe fan alle besteande motoren. Yn 'e wrâld fan kaders, wêr't elkenien besiket te automatisearjen, sille jo leare hoe te meitsjen, net te brûken. Begryp de aard fan kompjûters. En jo sille ek in folle mear yntelliginte en folwoeksen programmeur wurde - in pro.
Good luck op jo keazen paad! En lit ús de wrâld profesjoneler meitsje.
Author: , DevOps
Boarne: www.habr.com