JavaScript ఇప్పుడు ఉన్నట్లు ఉండాలని ఎప్పుడూ అనుకోలేదు. 1995లో, Brendan Eich Netscapeలో కూర్చుని పది రోజుల్లో ఒక ప్రోటోటైప్ను రూపొందించారు. పది రోజులు. కోట్లాది పరికరాలకు శక్తినిచ్చే ప్రోగ్రామింగ్ లాంగ్వేజ్ను డిజైన్ చేయడం పక్కన పెడితే, ఒక మంచి స్పెసిఫికేషన్ను రాయడానికి కూడా అది సరిపోదు. దీని ఫలితంగా డెవలపర్లు మూడు దశాబ్దాల తర్వాత కూడా తడబడే కొన్ని వింత లక్షణాలు ఉన్న భాష తయారైంది. అయినప్పటికీ, అదే తొందరగా చేసిన సృష్టి సాఫ్ట్వేర్ చరిత్రలో అత్యధికంగా ఉపయోగించబడే రన్టైమ్గా మారింది. ఇది అందంగా ఉండటం వల్ల కాదు, వెబ్కు అవసరమైన సరిగ్గా అదే సమయంలో బ్రౌజర్లో అందుబాటులోకి రావడం వల్ల విజయం సాధించింది.
తొందరలో పుట్టినది
తొలినాటి బ్రౌజర్ యుద్ధాలు స్నేహపూర్వక పోటీలు కావు. Netscape తన Navigator బ్రౌజర్లో Javaతో పాటు నడవగలిగే తేలికపాటి స్క్రిప్టింగ్ లాంగ్వేజ్ కావాలనుకుంది. ఎగ్జిక్యూటివ్లను సంతృప్తి పరచడానికి Java లాగే కనిపించేలా, కానీ నాన్-ప్రోగ్రామర్లు వెబ్ పేజీలలో సులభంగా పేస్ట్ చేయగలిగేలా ఏదైనా నిర్మించమని Eich కి బాధ్యత అప్పగించారు. గడువు సమయం చాలా తక్కువగా ఉంది. ఆయన Mochaను రూపొందించారు, అది త్వరలో LiveScript గా, చివరగా Java ప్రజాదరణను ఉపయోగించుకోవడానికి మార్కెటింగ్ వ్యూహంగా JavaScript గా పేరు మార్చబడింది.
ఆ తొందరపాటు వల్ల శాశ్వత లోపాలు మిగిలిపోయాయి. ప్లస్ ఆపరేటర్ హెచ్చరిక లేకుండా స్ట్రింగ్స్ మరియు నంబర్లను కలిపేటప్పుడు (concatenates), Type coercion ఇప్పటికీ కొత్తవారిని అయోమయానికి గురిచేస్తుంది. అసలు ఇంప్లిమెంటేషన్లో ఉన్న ఒక బగ్ వల్ల typeof null అనేది "object" అని రిటర్న్ చేస్తుంది, వెబ్ను దెబ్బతీస్తామనే భయంతో ఎవరూ దానిని సరిచేయడానికి సాహసించరు. Automatic semicolon insertion వల్ల సైలెంట్ ఫెయిల్యూర్స్ జరుగుతాయి. var తో డిక్లేర్ చేసిన వేరియబుల్స్ ఊహించని విధంగా స్కోప్ను లీక్ చేస్తాయి. ఇవి కేవలం అబ్స్ట్రాక్ట్ డిజైన్ లోపాలు మాత్రమే కాదు. ఇవి మే 1995లో జరిగిన రెండు వారాల వేగవంతమైన పని వల్ల ఏర్పడిన రోజువారీ ఇబ్బందులు.
వింతైన మూలాలు
JavaScript ను నిశితంగా గమనిస్తే, మూడు విభిన్న వంశపారంపర్యాలు కలిసి ఉన్నాయని మీరు చూస్తారు. దీని సింటాక్స్ Java నుండి ఎక్కువగా గ్రహించబడింది. కర్లీ బ్రేసెస్, if స్టేట్మెంట్లు మరియు for లూప్లు C-style భాషల నుండి వచ్చిన వారికి పరిచయంగా ఉంటాయి. కానీ ఆ ఉపరితలం కింద, దాని ప్రవర్తన పూర్తిగా భిన్నంగా ఉంటుంది.
ఈ భాష యొక్క అసలైన కంప్యూటేషనల్ హార్ట్ Lisp యొక్క మాండలికమైన Scheme నుండి వచ్చింది. JavaScript కి ఫస్ట్-క్లాస్ ఫంక్షన్స్ (first-class functions) ఇక్కడి నుండే వచ్చాయి, అంటే ఫంక్షన్లను ఆర్గ్యుమెంట్లుగా పంపవచ్చు, ఇతర ఫంక్షన్ల నుండి రిటర్న్ చేయవచ్చు మరియు వేరియబుల్స్కు కేటాయించవచ్చు. ఇది మనకు క్లోజర్స్ (closures) ను కూడా ఇచ్చింది, ఇవి ఒక ఇన్నర్ ఫంక్షన్, అవుటర్ ఫంక్షన్ అమలు పూర్తయిన తర్వాత కూడా దాని స్కోప్ను యాక్సెస్ చేయడానికి అనుమతిస్తాయి. మీరు ఎప్పుడైనా callback రాసినా లేదా event listener ను అటాచ్ చేసినా, మీరు Scheme నుండి వారసత్వంగా వచ్చిన DNA ను ఉపయోగించినట్లే.
ఆ తర్వాత ఆబ్జెక్ట్ మోడల్ ఉంది, ఇది Self నుండి వచ్చింది. కఠినమైన క్లాసులతో కూడిన క్లాసికల్ ఇన్హెరిటెన్స్ కు బదులుగా, JavaScript ప్రోటోటైప్స్ (prototypes) ను ఉపయోగిస్తుంది. ఒక ఆబ్జెక్ట్ నేరుగా మరొక ఆబ్జెక్ట్కు లింక్ అవ్వచ్చు మరియు ప్రాపర్టీ లుకప్లను పైకి డెలిగేట్ చేయవచ్చు. మీరు Object.create తో ఒక ఆబ్జెక్ట్ను సృష్టించవచ్చు మరియు క్లాస్ను నిర్వచించకుండానే చైన్లను నిర్మించవచ్చు. ఆధునిక JavaScript class కీవర్డ్ను జోడించింది, కానీ ఇది ఎక్కువగా ఈ అంతర్లీన ప్రోటోటైప్ మెకానిజంపై ఒక syntactic sugar మాత్రమే.
పేజీ అలంకరణ నుండి శక్తివంతమైన సాధనంగా
తన మొదటి కొన్ని సంవత్సరాలలో, JavaScript చిన్న పనులను మాత్రమే చేసేది. సర్వర్కు ఫారమ్ సబ్మిషన్ చేరుకోకముందే అది ఫారమ్ ఇన్పుట్లను వాలిడేట్ చేసేది. మౌస్ హోవర్ చేసినప్పుడు చిత్రాలను మార్చేది. అది ఒక బొమ్మ లాంటిది, టూల్ కాదు. బ్రౌజర్ ఇంప్లిమెంటేషన్లు అసమానంగా ఉండేవి, కాబట్టి డెవలపర్లు తరచుగా Netscape మరియు Internet Explorer కోసం వేర్వేరు కోడ్ పాత్లను రాసేవారు.
ECMAScript ద్వారా ప్రమాణీకరణ (Standardization) ఆ గమనాన్ని మార్చింది. ఈ స్పెసిఫికేషన్ బ్రౌజర్ వెండర్లకు అమలు చేయడానికి ఒక ఉమ్మడి లక్ష్యాన్ని ఇచ్చింది, ఇది నెమ్మదిగా అత్యంత చెడు అసమతుల్యతలను సరిదిద్దింది. ఆ తర్వాత Ajax వచ్చింది.
Ajax, అంటే Asynchronous JavaScript and XML, అనేది ఒకే కొత్త సాంకేతికత కాదు, కానీ ఉన్న భాగాలను కలిపే ఒక ప్యాటర్న్. దీనిలోని కీలకమైన అంశం XMLHttpRequest ఆబ్జెక్ట్, ఇది మొత్తం పేజీని రీలోడ్ చేయకుండానే బ్యాక్గ్రౌండ్లో డేటా కోసం సర్వర్ను అడగడానికి బ్రౌజర్ను అనుమతిస్తుంది. Google 2005లో Maps ని మరియు 2004లో Gmail ని ప్రారంభించినప్పుడు, వినియోగదారులు అకస్మాత్తుగా బ్రౌజర్ ట్యాబ్ లోపల డెస్క్టాప్ వంటి స్పందనను అనుభవించారు. వెబ్ పేజీలు అప్లికేషన్లుగా మారాయి. JavaScript ఇకపై కేవలం అలంకరణ మాత్రమే కాదు, అది ప్రధాన వంటకం అయింది.
వేగం మరియు ఆశయం
మునుపు రా (raw) పెర్ఫార్మెన్స్ అనేది JavaScript యొక్క అతిపెద్ద జోక్. ప్రారంభ ఇంటర్ప్రెటర్లు నెమ్మదిగా ఉండేవి. ఆ తర్వాత Google 2008లో Chromeతో పాటు V8 ఇంజిన్ను విడుదల చేసింది, అప్పటి నుండి ఆ జోక్ నవ్వు తెప్పించడం మానేసింది. V8 just-in-time compilation ను పరిచయం చేసింది, ఇది JavaScript ను లైన్ బై లైన్ ఇంటర్ప్రెట్ చేయడానికి బదులుగా రన్టైమ్లో మెషిన్ కోడ్గా మారుస్తుంది. డైనమిక్ ఆబ్జెక్ట్లపై కూడా ప్రాపర్టీ యాక్సెస్ను వేగంగా చేయడానికి ఇది hidden classes మరియు inline caching ను పరిచయం చేసింది. ఇతర బ్రౌజర్లు వాటి స్వంత హై-స్పీడ్ ఇంజిన్లతో స్పందించాయి, మరియు భాష అకస్మాత్తుగా నిజమైన కంప్యూటేషన్ కోసం తగినంత వేగంగా మారింది.
ఆ వేగం తదుపరి మార్పుకు దారితీసింది. Ryan Dahl 2009లో Node.jsని విడుదల చేశారు, V8ని బ్రౌజర్ నుండి వేరు చేసి, దానిని event-driven, non-blocking input-output మోడల్లో పొందుపరిచారు. వెబ్ సర్వర్లు ప్రతి కొత్త రిక్వెస్ట్ కోసం ఒక కొత్త త్రెడ్ను (thread) సృష్టించేవి, దీనివల్ల అధిక కన్కరెన్సీ (concurrency) ఉన్నప్పుడు అవి విఫలమయ్యేవి. Node.js ఒకే త్రెడ్పై event loop మరియు asynchronous callbacks ఉపయోగించి వేల సంఖ్యలో ఏకకాలపు కనెక్షన్లను నిర్వహించగలిగింది. JavaScript క్లయింట్ నుండి సర్వర్లోకి, బిల్డ్ టూల్స్లోకి మరియు చివరికి అన్నింటిలోకి విస్తరించింది.
సర్వవ్యాప్త భాష
ఇప్పుడు JavaScript దాని సృష్టికర్త ఊహించని చోట్ల కూడా నడుస్తోంది.
ఫ్రంటెండ్లో, React మరియు Vue ఆధునిక ఇంటర్ఫేస్లు ఎలా నిర్మించబడాలో నిర్ణయిస్తాయి. బ్రౌజర్ ఖరీదైన ఫుల్-పేజీ రీలోడ్లను చేయకుండానే, స్టేట్ మార్పులకు అనుగుణంగా కాంపోనెంట్స్ అప్డేట్ అవుతాయి. బ్యాకెండ్లో, Node.js APIs మరియు రియల్-టైమ్ సర్వీసులను నడుపుతుంది, అదే సమయంలో Bun వంటి కొత్త రన్టైమ్లు వేగవంతమైన ప్యాకేజీ మేనేజ్మెంట్ మరియు బిల్ట్-ఇన్ బండిలింగ్తో ప్రయోగాలు చేస్తున్నాయి.
React Native, JavaScript కోడ్ను నేటివ్ ప్లాట్ఫామ్ వ్యూస్గా మారుస్తుంది, దీనివల్ల డెవలపర్లు Swift మరియు Kotlin లలో రెండు వేర్వేరు కోడ్బేస్లను నిర్వహించాల్సిన అవసరం లేకుండానే iOS మరియు Android కోసం మొబైల్ అప్లికేషన్లను విడుదల చేయవచ్చు. Electron, డెస్క్టాప్ సాఫ్ట్వేర్ను నిర్మించడానికి వెబ్ టెక్నాలజీలను Chromium షెల్ లోపల ఉంచుతుంది, Slack మరియు Visual Studio Code కూడా మీ లాప్టాప్లోకి ఈ విధంగానే వస్తాయి. ఈ భాష క్లౌడ్ ఫంక్షన్లు మరియు ఎడ్జ్ కంప్యూటింగ్ వర్కర్లలో కూడా ఉంటుంది, ఇది డిస్ట్రిబ్యూటెడ్ నెట్వర్క్ల ద్వారా ఎండ్ యూజర్కు కొన్ని మిల్లీసెకన్ల దూరంలోనే లాజిక్ను అమలు చేస్తుంది.
సమృద్ధిలోని వైరుధ్యం
సర్వవ్యాప్తతకు ఒక మూల్యం ఉంది. ఈ ఎకోసిస్టమ్ చాలా పెద్దది, మరియు ఆ పరిమాణం ఆందోళనను కలిగిస్తుంది. మీరు చివరి బిల్డ్ టూల్ను కాన్ఫిగర్ చేయడం పూర్తి చేయకముందే, మరొక కొత్త బిల్డ్ టూల్ ప్రత్యక్షమవుతుంది. ఫ్రేమ్వర్క్ల ప్రజాదరణ కాలక్రమంలో సీజన్ల మాదిరిగా పెరుగుతూ తగ్గుతూ ఉంటుంది. మీరు JavaScript ప్రపంచాన్ని వదిలి వెళ్లకుండానే దాదాపు ఏ సమస్యనైనా పరిష్కరించవచ్చు, కానీ ముందుగా మీరు డజన్ల కొద్దీ విభిన్నమైన (highly opinionated) పరిష్కారాల నుండి ఒకటి ఎంచుకోవాలి. డిపెండెన్సీ ట్రీలు (Dependency trees) లోతుగా మరియు పెళుసుగా మారుతాయి. ఒక ప్యాకేజీ రిజిస్ట్రీ నుండి మాయమైతే, అది వేల సంఖ్యలో ఇతర ప్రాజెక్ట్లను దెబ్బతీస్తుంది (ఉదాహరణకు arrays కోసం left-padding చేసే ప్యాకేజీ).
ఇవేవీ అనుకోకుండా జరగవు. వెబ్ గందరగోళంగా ఉన్నందున JavaScript కూడా గందరగోళంగా ఉంటుంది. ఇది బ్యాక్వర్డ్ కంపాటబిలిటీ, తొందరగా రూపొందించిన ప్రమాణాలు మరియు పోటీతత్వంతో కూడిన ఇంప్లిమెంటేషన్ల కలయికతో ఏర్పడిన ఒక సంక్లిష్టమైన నిర్మాణం. అయినప్పటికీ, ఆ గందరగోళమే ఈ భాషను శక్తివంతంగా మారుస్తుంది. వెబ్ ప్రతిచోటా ఉంది, మరియు JavaScript డిఫాల్ట్గా ప్రతి బ్రౌజర్లో ఉండటం వల్ల, ఇది మనకు అందుబాటులో ఉన్న యూనివర్సల్ రన్టైమ్కు అత్యంత దగ్గరగా ఉంటుంది.
ఇది కేవలం స్క్రిప్టింగ్ లాంగ్వేజ్ మాత్రమే కావడం ఎప్పుడో ఆగిపోయింది. JavaScript ఇప్పుడు సాఫ్ట్వేర్ కోసం ఒక గ్లోబల్ ప్లాట్ఫామ్, ఇది పది రోజుల్లో నిర్మించబడింది, మరియు వెబ్ గతంలో ఉన్న వాటిని దెబ్బతీయకూడదనే అదృశ్య ఒప్పందంతో ఇది నిలకడగా ఉంది. దీని బలాలు మరియు లోపాలను కలిపి నేర్చుకుంటే, మీరు ఆధునిక ఇంటర్నెట్ చరిత్రనే నేర్చుకుంటున్నట్లు లెక్క.