Novi jezici: Go, Rust, Swift, Kotlin, TypeScript

Zamisli industriju kao čovjeka koji trideset godina nosi isti kaput. Kaput ima rupu na lijevom džepu — kroz nju mu ispadaju kovanice, otprilike, kažu računovođe, milijardu dolara ukupno u zadnjih nekoliko desetljeća — i zna se točno gdje je rupa, otkad je i tko je šivao. Ipak, umjesto da je zakrpa, čovjek svako toliko stane pred ogledalo, pogleda tu rupu, kaže „da, znam za nju” i — nastavi je nositi. Tako je izgledala softverska industrija do otprilike 2010. godine. Rupa se zvala null pointer — u prijevodu, mjesto u memoriji na koje program pokazuje kao da tamo nešto postoji, a ono tamo, iznenađenje, nema ništa; program pokuša posegnuti za tom nepostojećom stvari i sruši se, otprilike kao kad posegneš rukom u džep po kikiriki koji si sto puta prije tamo nalazio, a ovaj put je džep prazan i ruka ti prođe kroza rub. A čovjek koji je prišio dizajn koji je tu rupu uzrokovao, Tony Hoare, javno je izašao i rekao da je to najskuplja greška njegove karijere. Ne u knjizi, ne u intervjuu za nišnu publiku — pred cijelom strukom, glasno, s brojkom. Rijetko se dogodi da izumitelj sam sebi presudi. On je to učinio.

A null pointer nije bio jedini stanar tog kaputa. Tu je bio i C++, koji je za svaku sitnicu tražio ceremoniju — hoćeš zbrojiti dva broja, moraš prvo popuniti tri formulara i potpisati kod javnog bilježnika (to je, dakako, pretjerivanje, ali osjećaj je bio takav). Tu su bili memory bugovi, ona ista kamata koja se od sedamdesetih tiho gomilala u svakom projektu pisanom u C-u — segfault ovdje, use-after-free ondje, cijela jedna industrija sigurnosnih firmi izgrađena isključivo na čišćenju nereda koji je, teoretski, bio izbježiv od prvog dana. I tu je bio JavaScript, koji je u dvijetisućima narastao iz igračke za validaciju formulara u kostur pola interneta, dok mu je tipni sustav — pravilo koje kaže kakvu vrstu podatka neka varijabla smije nositi, broj, tekst, listu i tako dalje, slično kao što ladica za čarape ne bi trebala primati i tanjure — i dalje bio otprilike na razini „baci sve u jednu vreću i vidi što ispadne”.

Trideset godina svi su znali dijagnozu. Trideset godina nitko nije napisao recept — jer prepisati cijeli jezik znači prepisati milijune postojećih programa, a to nitko normalan ne radi za zabavu. Onda se, u razmaku od jedva pet godina, dogodilo nešto što ni sama industrija nije baš planirala kao dogovor, a ispalo je kao jedan: pet velikih firmi, svaka izgrizena svojim vlastitim konkretnim problemom, sjelo je i napisalo pet novih jezika. Ne akademske vježbe za konferencije, nego jezike s proizvodnjom — pravim, živim kodom u pogonu — iza sebe od prvog dana.

Google je bio umoran od toga da mu se kompajlacija vuče minutama dok inženjeri piju kavu i gledaju u zid. Mozilla je bila umorna od toga da joj preglednik puca zbog memorije koju je netko negdje zaboravio osloboditi. Apple je bio umoran od jezika koji je zvučao kao da ga je pisao netko iz osamdesetih (jer i jest). JetBrains je bio umoran čekajući da Java evoluira brzinom kornjače. A jedan čovjek u Microsoftu, koji se u ovoj enciklopediji već pojavio triput pod drugim imenima, jednostavno je htio da postojeći JavaScript ne mora nitko ponovno pisati da bi dobio tipove.

Google, negdje sredinom 2000-ih. Zamisli zgradu punu inženjera koji čekaju. Ne čekaju kavu, ne čekaju sastanak — čekaju da im se C++ kod kompajlira, to jest da se njihov napisani program pretvori u nešto što računalo zapravo razumije i može pokrenuti. Petnaest minuta. Ponekad pola sata. Netko je jednom izračunao koliko čovjek-sati godišnje Google izgubi na to gledanje u traku napretka, i broj je bio toliko sramotan da su ga vjerojatno zaključali u isti sef gdje čuvaju algoritam pretraživanja.

I tu upadaju trojica: Rob Pike, Robert Griesemer i — pazi sad — Ken Thompson. Da, taj Ken Thompson. Isti čovjek koji je s Dennisom Ritchiem sklepao Unix na stroju koji je zapravo trebao samo igrati igricu Space Travel, isti koji se pojavljuje i kao autor B-jezika iz kojeg je Ritchie izvukao C. Čovjek je već dvaput promijenio industriju iz dosade i nužde. Sad je star, ima preko šezdeset, i umjesto da se povuče na zasluženi mir uz nekakav penzionerski hobi, sjedne s dvojicom kolega i kaže: dosta mi je čekanja. Treći put. Ozbiljno, ako ovaj čovjek ikad napiše memoare, jedino poglavlje koje nedostaje je ono gdje izumi kotač.

Rezultat se zvao Go, objavljen 2009., i prva stvar koju primijetiš kad ga pogledaš je koliko toga — nema. Nema nasljeđivanja klasa (onog koncepta gdje jedan tip koda „nasljeđuje” osobine drugog, kao dijete koje pokupi navike od roditelja — zgodno na papiru, u praksi često izvor zbrke). Nema iznimki (exceptions) u onom obliku na koji si naviknut iz Jave ili C++-a — greške se vraćaju kao obične vrijednosti, ne bacaju se kao granate koje moraš hvatati u letu. Nema generičkih parametara u prvoj verziji — to je mogućnost da se jedan komad koda napiše tako da radi s bilo kojim tipom podatka, umjesto da ga pišeš iznova za brojeve, pa iznova za tekst, pa iznova za sve ostalo — dodani su tek godinama kasnije, uz škrgutanje zuba pola interneta. Go dizajneri nisu dodavali značajke da bi impresionirali konferencijsku publiku — oduzimali su ih. I kad ih pitaš zašto je jezik toliko jednostavan da izgleda kao da mu je nešto ozbiljno nedostajalo, oni to prihvate kao kompliment. „Dosadan” je za Go pohvala, ne uvreda. Dosadan jezik znači da se nemaš čemu iznenaditi u tuđem kodu u tri ujutro kad ti nešto pukne u produkciji.

Ali prava poanta Goa, ono zbog čega je Google zapravo trpio bol pisanja novog jezika umjesto da samo strpljivije čeka bolji kompajler, zove se konkurentnost — sposobnost da se više stvari radi „istovremeno”, bez da program stane i čeka svaku od njih redom. I ovdje treba stati na trenutak, jer je ovo jedna od onih ideja koja zvuči kompliciranije nego što zapravo jest.

Zamisli konobara u restoranu. Loš konobar radi jednu stvar odjednom — ode do stola, uzme narudžbu, odnese je u kuhinju, stoji i čeka da se jelo skuha, tek onda ide po sljedeći stol. Katastrofa, red se stvara do vrata. Dobar konobar uzme narudžbu, baci je kuhinji, ode do drugog stola dok se jelo kuha, uzme treću narudžbu, vrati se po gotovo jelo — sve istovremeno, sve u glavi jednog čovjeka koji jednostavno ne čeka uzalud. Upravo to su goroutines. Sitne, jeftine „radnice” koje jezik pokreće u tisućama komada, bez da ti moraš ručno upravljati dretvama (threadovima) kao nekim skupim, kapricioznim resursom. U starim jezicima paralelan rad bio je nešto što si dodavao naknadno, uz muku, biblioteke i molitvu. U Go-u je to ugrađeno u samu gramatiku jezika — napišeš `go` ispred funkcije i ona kreće u svoju paralelnu smjenu, dok glavni tok priče ide dalje.

Ironija je, priznat ćeš, dobra: jezik rođen iz nestrpljenja postao je jezik koji tiho i strpljivo, u pozadini, drži gotovo sve što danas zoveš »cloudom«. Thompson je, čini se, i treći put pogodio pravu žicu — samo što ovaj put nije čekao da netko drugi napravi Unix pa da on izvuče poantu. Ovaj put je odmah znao što gradi.

Dok je Google u svom laboratoriju rješavao problem sporih kompajlera, u Mozilli je jedan inženjer imao mnogo neugodniji problem: Firefox je padao. Ne povremeno, ne rijetko — nego redovito, na način koji je upućivao na istog starog zločinca iz jednog od prijašnjih poglavlja ove knjige. Memorija. Netko je pisao u dio memorije koji više nije njegov, netko je čitao pokazivač koji je već obrisan, netko je zaboravio osloboditi nešto što drugi dio programa još koristi. Klasika. Grijeh star koliko i C, star koliko i C++, star koliko i sam koncept da programer ručno upravlja time gdje mu podaci žive i kada umiru.

Zove se Graydon Hoare. I da, prije nego pitaš — nije rod s onim drugim Hoareom, onim koji se u jednom od ranijih poglavlja ove knjige ispričao svijetu za izum nulte referenca, grešku koja je desetljećima rušila programe širom planeta. Ali gotovo da je poetično da se u ovoj priči jave dva čovjeka istog prezimena, obojica opterećena istom vrstom grijeha koji je industrija desetljećima gutala kao neizbježan porez na postojanje. Jedan je smislio grešku. Drugi je, četrdesetak godina kasnije, smislio jezik koji tu vrstu greške čini gotovo nemogućom da se napiše.

Rust je počeo 2006. kao Hoareov osobni projekt, Mozilla ga je pokupila kao sponzoriranu igračku 2009. i javno ga objavila 2010., dok je prva prava verzija za javnost izašla par godina kasnije. Poanta jezika zvučala je kao heretička: memorijska sigurnost bez garbage collectora — onog automatskog čistača koji u jezicima kao Java ili Go s vremena na vrijeme prošeta kroz memoriju i pobriše što se više ne koristi, dok programer sjedi i ne brine se ni o čemu. Rust je htio istu sigurnost, ali bez tog čistača koji radi u pozadini i jede vrijeme i procesor — kompajler sam, u trenutku kompajliranja, mora znati hoćeš li slučajno pristupiti nečemu što ne postoji, i to zaustavlja PRIJE nego program uopće krene, ne kad ti padne u ponoć na produkciji.

Kako to izgleda u praksi? Zamisli knjižnicu. Strogu, pedantnu knjižnicu s knjižničarkom koja pamti apsolutno sve. Kad uzmeš knjigu, ona je tvoja — dok je vraćaš. Ako je netko drugi uzme u međuvremenu, znaš da je nema, i knjižnica to neće dopustiti dvaput. Ako uzmeš knjigu na posudbu „na čitanje”, možeš je gledati koliko hoćeš, i drugi je mogu gledati s tobom — ali nitko ne smije pisati u nju dok je ti čitaš. A ako je uzmeš na posudbu „za pisanje”, ti si jedini koji je smije i dotaknuti dok je držiš. Kad je vratiš, netko drugi napokon smije. Nema dvostrukog vraćanja, nema čitanja obrisane knjige, nema dvije osobe koje pišu u istu stranicu istovremeno i pretvore rečenicu u kaos.

Ta pravila — vlasništvo, posudba, životni vijek — Rust naziva ownership i borrow checking, i to je čitav mehanizam koji radi upravo ono što knjižničarka radi: ne dopušta ti da zabrljaš, čak ako to iskreno želiš. Kompajler odbija prevesti kod koji krši pravila. Ne upozorava. Odbija. Nema izvršavanja, nema runtime greške za tri mjeseca kad je već prekasno — greška je uhvaćena u trenutku pisanja, tamo gdje je najjeftinija.

Zato je svetinja koju je industrija desetljećima smatrala fizikalnim zakonom — brzina C-a i sigurnost visokorazinskog jezika ne idu zajedno, biraj jedno — jednostavno prestala vrijediti. Rust se kompilira u strojni kod bez ikakvog usporavanja koje bi ti nametnuo garbage collector, radi brzinom usporedivom s C++, a memorijske greške koje su desetljećima punile baze sigurnosnih propusta (onaj isti dug iz prijašnjeg poglavlja, sjećaš se, kamate koje je C ostavio nasljednicima) postaju kategorija bugova koju u Rustu praktički ne pišeš. Ne zato što si bolji programer. Zato što ti kompajler to jednostavno ne dopušta.

Posljedica je bila neobičan fenomen za programski jezik: kult, i to zaslužen. Rust je od 2016. godinama zaredom bio najvoljeniji jezik u Stack Overflow anketama (godišnjem istraživanju među programerima iz cijelog svijeta) — ne najkorišteniji, ne najveći po broju poslova, nego onaj koji ljudi koji ga koriste najviše VOLE koristiti. To je rijetka kombinacija: jezik koji te tjera da patiš u učenju, a onda te nagradi osjećajem da ti se program neće raspasti u tri ujutro.

Dok je Google gradio Go za svoje poslužitelje, desetak kilometara južnije Apple je imao drugi problem. Objective-C je bio jezik s bradom — literalno, sintaksa uglatih zagrada koja izgleda kao da je Smalltalk spario s C-om i dobio dijete koje nitko nije htio priznati na roditeljskom sastanku. Radio je, generacijama je pokretao Mac i iPhone, ali svaki nov developer koji bi ga prvi put vidio napravio bi istu grimasu — onu koju napraviš kad probaš tuđu kavu bez šećera a mislio si da je tvoja.

Chris Lattner, čovjek koji je prije toga u tišini sagradio LLVM (infrastrukturu na kojoj danas sjedi pola svjetskih kompajlera, uključujući, usput, i Rust iz prošlog poglavlja), dobio je zadatak da smisli Objective-C-u nasljednika. Rezultat se zvao Swift, a najpametnija odluka nije bila u sintaksi, nego u tzv. playgroundu — doslovno prozoru u kojem pišeš kod i odmah, u stvarnom vremenu, gledaš graf kako se crta ili lik kako se pomiče, bez da ikad pritisneš »compile«. Apple nije samo mijenjao jezik, učio je novu generaciju da programiranje ne mora biti mračna umjetnost sa zakašnjelom povratnom informacijom — može biti crtanje. Playground je pedagoški trik stariji od informatike, samo prerušen u Xcode.

Otprilike u istom desetljeću, na drugoj strani planeta, JetBrains — firma poznata po tome da pravi alate kojima drugi developeri programiraju, ne po tome da pravi jezike — imala je svoju frustraciju. Java je bila radni konj Androida, stabilna, s ogromnom bazom koda, ali evoluirala je sporošću koja bi osramotila i ledenjak. Svaka nova značajka prolazila je kroz komitete, procese i godine čekanja dok je Oracle — koji je Javu preuzeo kad je kupio Sun i onda, dodatna informacija, ne moraš ovo znati ali ne škodi, otvorio jedan od najdužih sudskih ratova u povijesti softvera protiv samog Googlea oko upravo te Jave — sjedio na jeziku kao zmaj na zlatu. JetBrains nije čekao. Napravio je Kotlin: jezik koji se, kad ga kompajliraš, ne pretvara u nešto što razumije samo jedan procesor, nego u bajtkod — međukod koji izvršava virtualna mašina, zamisli ju kao univerzalnog prevoditelja koji svakom procesoru na svijetu govori isti jezik. Java taj isti bajtkod proizvodi desetljećima, pa Kotlin, koji ga proizvodi na potpuno isti način i pušta ga na istu virtualnu mašinu (JVM), automatski dobiva pristup cijeloj toj gomili postojećih Javinih biblioteka, besplatno, kao da je uvijek bio dio obitelji. I uz to briše polovicu gnjavaže — null-sigurnost ugrađenu u tip sustav, sintaksu koja ne traži da napišeš tri retka da bi rekao jednu misao.

I onda je Google, koji je vjerojatno imao dovoljno razloga za nervozu oko svega što nosi natpis Java, 2017. jednostavno rekao: Kotlin je sada službeni jezik Androida. Ne opcija u dnu popisa negdje pri izborniku, nego prva liga, glavna postava. I tu je runda koja se ponavlja kroz cijelo ovo poglavlje dobila svoj najčišći oblik — jezik ne pobjeđuje jer je bolji na papiru, jezik pobjeđuje jer platforma odluči da pobjeđuje. Milijuni Android developera koji ujutro nisu ni znali da Kotlin postoji, do večeri su čitali dokumentaciju, ne zato što su glasali, nego zato što je platforma glasala za njih.

Isto se dogodilo s iOS-om i Swiftom, samo bez drame — Apple ne pita, Apple objavi, a developerska baza se preseli u sljedećih par godina, jer alternativa je ostati na jeziku koji sam proizvođač polako gura u mirovinu. To je moć koju ni Go ni Rust nemaju, koliko god bili elegantni: platforma ne mora uvjeravati. Samo promijeni zadanu postavku, i cijela industrija se okrene kao jato riba za jednim vođom, bez sastanka, bez glasanja, bez da ikoga to iznenadi.

Isti Hejlsberg koji je već triput promijenio industriju, ovaj put je pogledao u JavaScript i rekao: znate što, treba mu tipovi.

I onda, 2012. godine, čovjek koji je već tri puta promijenio industriju, u dobi kad većina ljudi razmišlja o tome hoće li stići do mirovine, sjeda i kaže: znate što, JavaScript treba tipove. Ne novi jezik. Ne zamjenu. Tipove — onu stvar koja kompajleru unaprijed govori je li nešto broj, tekst ili nešto treće, pa ako pokušaš u kutiju za brojeve strpati riječ „mačka”, on to prigovori odmah, a ne tek kad se program raspadne u produkciji. Umetnute u postojeći jezik, kao žlica šećera u kavu koja je predobra da bi je bacio, ali predosadna da je piješ takvu kakva je.

I tu je genijalnost poteza, ona vrsta koja izgleda jednostavno tek kad je netko drugi već napravio. TypeScript nije novi jezik u smislu da moraš baciti kod i početi ispočetka — TypeScript je nadskup JavaScripta. Svaki .js fajl koji imaš, svaka ta desetogodišnja spaghetti-baza koda koju nitko ne smije dirati jer se ne zna zašto radi, ali radi — to je već valjani TypeScript. Preimenuješ ekstenziju u .ts i gotovo, kompajlira. Nema migracije, nema prepisivanja, nema onog poglavlja gdje C++ programeri plaču nad ceremonijom prelaska na nešto „bolje” (ono skupo naučeno, kao i uvijek kad je riječ o migraciji milijuna linija koda, da ljudi neće prepisati sve to samo zato što im netko kaže da je novo bolje). Hejlsberg je to znao unaprijed. Migracijski trošak nula bio je dizajn, ne sreća.

Onda dolazi ono što se u struci zove gradual typing, a što ja volim zvati — tipovi na cijeđenje. Ne moraš odjednom otipizirati cijelu bazu koda. Možeš staviti tip na jednu funkciju, ostaviti sve ostalo kako je, i kompajler će ti reći gdje ta jedna funkcija sad ne pristaje s onim što je oko nje. Postupno, fajl po fajl, tim po tim, dok jednog dana ne skužiš da ti cijela baza šapuće što smije ući, a što ne. Nitko te nije natjerao. Samo si, korak po korak, prihvatio da je bolje znati unaprijed da si nekoj funkciji poslao broj gdje očekuje tekst (string, u žargonu), nego to otkriti u produkciji, u petak navečer, dok ti telefon zvoni.

Reakcija zajednice, da budemo pošteni, nije bila oda zahvalnosti. Prve godine TypeScript je dočekan s onom vrstom podsmijeha koju rezerviraš za rođaka koji se vratio iz Amerike i sad govori hrvatski s naglaskom. „Microsoft kvari JavaScript”, pisalo je po forumima. „Zašto bih kompajleru davao posao koji radi moj mozak”, pitali su ljudi koji su mjesec dana kasnije satima tražili gdje im se u kodu potajno uvukao onaj undefined koji, prema njihovom mozgu, tamo nije smio postojati.

Danas brojke govore dovoljno glasno da ih ne treba previše komentirati: TypeScript je godinama među najkorištenijim jezicima na GitHubu, Angular — jedan od najpopularnijih alata za izradu web stranica — pisan je u njemu, veći dio moderne React zajednice (drugog takvog alata, možda i popularnijeg) ga uzima kao zadanu opciju, a novi projekt bez TypeScripta u 2020-ima traži objašnjenje — kao da si na sastanku rekao da ti auto nema pojas. Tehnički je moguće. Samo se pitaju zašto bi.

Hejlsberg je tako, po četvrti put u karijeri, odradio isti trik — pogodio je točno gdje industrija boli, i to bez teatra, bez konferencijske priče o revoluciji. Samo je sjeo i napisao nešto što rješava jedan konkretan problem. Njegova karijera je, ako je tako gledaš, najbolji dokaz da se najveći utjecaj na softversku industriju ne mjeri slavom, nego time koliko tiho možeš promijeniti kako milijuni ljudi rade, a da te pola njih ne prepozna na ulici.

OK, odmakni se malo i pogledaj sve pet jezika istovremeno, kao da ih gledaš s balkona. Go, Rust, Swift, Kotlin, TypeScript — nastali u različitim firmama, iz različitih frustracija, pisani od ljudi koji se međusobno nisu ni poznavali. I skoro svi rade istu stvar: guraju null-sigurnost u sustav tipova — Rust je nema ni kao opciju, Swift, Kotlin i TypeScript te tjeraju da se s njom nosiš već u kompajleru, dok je Go, iskreno, jedini koji je tu ostao pri starom i dalje živi s nilom kao i prije. Ali svi bez iznimke guraju tipove tamo gdje ih prije nije bilo, i svi stavljaju kompajler u ulogu asistenta koji ti prije pokretanja programa kaže — ovo će puknuti, popravi. Kad pet firmi koje se ne slažu ni oko toga koja je najbolja pizza dođe do istog zaključka neovisno jedna o drugoj, to nije trend. To je dijagnoza.

Jer to i jest dijagnoza. Cijela ta priča o kompajleru kao asistentu, a ne sucu — to je »developer experience«, kraće DX, iskustvo koje programer ima dok radi s alatom, i u 2010-ima je prestalo biti kozmetika i postalo disciplina. Prije toga je kompajler bio čuvar vrata: propusti te ili ne propusti, a ako ne propusti, dobar dan, sretno s porukom o grešci koja zvuči kao da je pisana na drevnom sumerskom. Rust ti kaže gdje je problem, zašto je problem, i često ti čak predloži kako da ga popraviš. To je razlika između policajca koji te samo kazni i mentora koji te uhvati prije nego zabrljaš. Ni jedno ni drugo nije ugodno u trenutku, ali jedno te barem nauči nešto.

A onda dođe ono što nitko voli reći naglas, pa ću ja: sintaksa ovih jezika je, u svojoj biti, pisana isprika. Trideset godina industrija je trpjela null pointer exceptione (program koji pokuša posegnuti za nečim što uopće ne postoji i zbog toga se sruši), buffer overflowove, tihe konverzije tipova koje pojedu bug i sakriju ga tri mjeseca dalje u produkciji — i sve je to, gotovo bez iznimke, bilo izbježivo. Ne teško izbježivo. Izbježivo od prvog dana, samo je to zahtijevalo da jezik ne dopusti programeru da napravi glupost, umjesto da mu vjeruje na riječ da neće. Tony Hoare, čovjek koji je null osobno izmislio, to je javno priznao — nazvao je to svojom »greškom od milijardu dolara«. Rust je isto priznanje ugradio u borrow checker, mehanizam koji već prije pokretanja programa provjeri tko u kojem trenutku »posjeduje« pravo korištenja neke memorije, umjesto da to prepusti garbage collectoru da čisti nered poslije (Rust uopće nema garbage collector, ali princip je isti — netko treba znati kad se memorija oslobađa, i borrow checker to rješava unaprijed). TypeScript je to učinio za tipove, u jeziku (JavaScriptu) koji tipove nikad nije ni htio imati. Svaki `?.` koji danas otipkaš bez razmišljanja — onaj mali upitnik koji jeziku kaže »provjeri prvo je li ovo null, pa mi tek onda javi vrijednost, umjesto da program sam pukne« — to je spomenik. Mali, neupadljiv, ali spomenik desetljećima bugova koji su nekome negdje probili produkciju u tri ujutro.

To je, uzgred, ista logika po kojoj je cijela ova industrija nastala. Sjeti se ALGOL-a, one davne zajedničke pretke iz koje su se poput obiteljskog stabla razgranala pola jezika koje danas spominjemo — nitko nije zbrisao prethodnika, svatko je samo dodao kat na temeljima koje su drugi već postavili i platili greškama za njih. Industrija se ne obnavlja rušenjem. Obnavlja se dogradnjom, sloj po sloj, dok stari kat nikome ne smeta jer i dalje drži krov.

Pa evo poante, jer ovo poglavlje ionako ide predugo bez nje: jezici 2010-ih nisu revolucija u smislu u kojem to marketing voli reći. Nitko nije izmislio računanje iznova. Cijeli val — Go, Rust, Swift, Kotlin, TypeScript — je industrija koja je, nakon tri desetljeća plaćanja kamata na iste greške, konačno sjela i napisala ispriku. Ne u e-mailu, ne u blog postu, ne u konferencijskom govoru sa slajdovima. Napisali su je u kompajleru — onom programu koji tvoj kod prevodi u nešto što računalo razumije, i koji sad, umjesto da šutke progura svaku glupost, prvi zastane i pita jesi li siguran. I sad, svaki put kad ti neki od tih jezika odbije da kompajlira kod dok ne popraviš null-check koji bi prije pukao tek u produkciji — to nije jezik koji je stroga baba. To je industrija koja ti, kroz crvenu poruku o grešci, tiho govori: znamo, jebemti, znamo, i evo, popravili smo bar ovo.