file_name,text
wavs/-UMAP97L5q4_vocals00000000.wav,"మా office లో చాలా సార్లు కొంతమంది Java fast అంటారు. ఇంకొంతమంది Java కాదు Node.js ఇంకా fast గా ఉంటది అంటారు. కొంతమందైతే ఆ రెండూ కాదు Python సూపర్ గా ఉంటది అంటారు. ఇంకొంతమంది వేరేగా వచ్చి ఆ మూడు కాదు గాని Go, Rust అని రెండు languages ఉన్నాయి అవైతే సూపర్ గా ఉంటాయి అంటారు"
wavs/-UMAP97L5q4_vocals00000332.wav,"అసలు నాకు ఎప్పుడు doubt ఏంటంటే ఎలా decide చేస్తారు ఏ language fast అని చెప్పేసని? So, ఈ decision తీసుకోవడం కోసం మనం ఏం చేద్దాం అంటే ఈరోజు ఒక చిన్న experiment చేద్దాం. ఈ experimentలో ఏం చేస్తామంటే ఒక API తీసుకుందాం"
wavs/-UMAP97L5q4_vocals00000571.wav,"మనం ఎప్పుడూ వాడే ఒక authentication API. దాంట్లో username, password ఇస్తే అది మనకి correct ఆ కాదా అని చెప్పేసి అని మనకి response ఇస్తది. ఇప్పుడు API ని మనం different languages తో రాద్దాం. రాసిన తర్వాత ప్రతి language కి మనం ఒకేసారి ఒక one lakh request ని hit చేద్దాం. hit చేసిన తర్వాత..."
wavs/-UMAP97L5q4_vocals00000930.wav,"అసలు ఆ language ఆ request ని ఎలా process చేస్తుంది, ఎంత time లో finish చేస్తుంది అనే దాన్ని చూద్దాం. దీన్ని బట్టి maybe మనకు కొంత idea రావచ్చు అన్న。 ఇప్పుడు ఈ video లోపలికి వెళ్ళగానే మనకి mainly ఇక్కడ observe చేస్తే ఒక front end ఉంది, ఒక back end ఉంది, అలాగే ఒక database ఉంది"
wavs/-UMAP97L5q4_vocals00001228.wav,"Front end నుంచి నువ్వు user name, password పంపించగానే అవి first back end దగ్గరికి వెళ్తాయి. Back end లోకి వెళ్లగానే back end లో మనం ఏం చేస్తాం? First దాన్ని ఒక http request లాగా process చేస్తాం. దాని తర్వాత DB నుంచి user ని తెచ్చుకుంటాం."
wavs/-UMAP97L5q4_vocals00001538.wav,దాని తర్వాత password ని match చేస్తాం. Match చేసిన తర్వాత response ఇస్తాం. Okay నా? ఇప్పుడు ఈ విధంగా నీ request అనేది process అవుతుంది. ఇప్పుడు మన experiment కోసం ఏం చేద్దాం అంటే DB నుంచి వచ్చే response ఎప్పుడూ hundred milliseconds ఉంటదని చెప్పేసి fix చేసి వెళ్దాం. At the same time ఈ backend machine కి ఒక configuration ఏం పెడదాం అంటే ఒక Linux తీసుకుందాము
wavs/-UMAP97L5q4_vocals00001950.wav,దాని తర్వాత దానికి ఒక 8GB RAM ఉందనుకుందాము. At the same time one core CPU ఉందనుకుందాం. ఓకే నా? ఇప్పుడు ఈ explanation తోని మనం different languages లో ఇది ఎలా work అవుద్ది అనేది చూద్దాం. వీటిలోకి వెళ్లే ముందు మనం main గా ఒక OS concept తెలుసుకుందాం.
wavs/-UMAP97L5q4_vocals00002247.wav,"ఆ OS concept ఏంటి అంటే, let's say మీది మీ computer లోని ఇదొక application layer ఇదొక OS layer. okay నా? ఇది మీ CPU. CPU పని ఏంటి? instructions ని execute చేయడం. CPU కి instructions ఎవరు ఇస్తారు? CPU కి ఒక thread ఉంటది అన్నమాట OS layer లో"
wavs/-UMAP97L5q4_vocals00002608.wav,"ఈ thread పని ఏంటంటే, మీరు ఈ thread కి instructions ఇచ్చారనుకోండి, ఆ thread ఏం చేస్తుందంటే CPU దగ్గరికి ఆ instructions పట్టుకెళ్ళి execute చేయించుకుంటాది. ఓకేనా? ఇప్పుడు అదే మీ దగ్గర చాలా ఎక్కువ threads ఉన్నాయనుకో, అప్పుడు ఎలాగవుతది? CPU at any point of time ఒకటే thread execute చేయగలదు."
wavs/-UMAP97L5q4_vocals00002988.wav,"దానికోసం OS scheduler అని ఒకటి ఉంటాదన్నమాట. ఈ OS scheduler ఏం చేస్తది అంటే మీ దగ్గర multiple threads ఉన్నాయనుకోండి, అది CPU కి కాసేపు ఈ thread ఇస్తది, కాసేపు ఈ thread ఇస్తది, కాసేపు ఈ thread ఇస్తది, కాసేపు ఈ thread ఇస్తది."
wavs/-UMAP97L5q4_vocals00003317.wav,అలాగా threads ని మారుస్తూ ఉంటాదన్నమాట. ఓకే నా? ఇప్పుడు ఒక thread నుంచి ఇంకో thread కి మార్చే time లో ఏమవుద్ధంటే కాస్త CPU time అనేది waste అయిపోద్ధన్నమాట. దాన్నే మనం context switching అంటాం. ఓకే నా? ఇది basic knowledge. ఇప్పుడు ఈ knowledge use చేసుకుని different different languages దీన్ని ఎలా వాడుకుంటున్నారు అనేది మనం ఒకసారి observe చేద్దాం.
wavs/-UMAP97L5q4_vocals00003826.wav,ముందుగా మనం Java దగ్గరికి వద్దాం. ఇక్కడ మీరు Java లో observe చేస్తే ఇది spring boot లో నేను రాసాను అనమాట. ఈ spring boot లోని ఈ method చూస్తే ఇది verify password అనేది exact గా చేస్తుంది.
wavs/-UMAP97L5q4_vocals00004044.wav,దీంట్లో ఒక email ఉంది ఒక password అనేది. ఇది నేను arguments గా pass చేస్తే first నేను user ని database నుంచి తెచ్చుకుంటున్నాను. దాని తర్వాతేమో ఆ user ఉన్నాడా లేదా అని check చేసుకుంటున్నాను. దాని తర్వాత password ని match చేస్తున్నాను. Match చేసిన తర్వాత true or false అని చెప్పేసి return చేస్తున్నాను.
wavs/-UMAP97L5q4_vocals00004388.wav,"ఇప్పుడు ఈ code అనేది Java లో రాసింది exact గా internal గా ఎలా work అవుద్ది అంటే, ఇలాంటి architecture అనేది లోపట ఉంటదన్నమాట. ఓకే నా? ఇది application layer, ఇది OS layer"
wavs/-UMAP97L5q4_vocals00004615.wav,"ఈ application layer లో మన spring boot server అయిన Tomcat ని run చేస్తున్నాం. Okay నా? ఇప్పుడు నువ్వు let's say నీకు ఒక request రాగానే authentication request రాగానే Tomcat ఏం చేస్తుందంటే నీకోసం ఒక OS thread ని create చేస్తదన్నమాట. నువ్వు ఇంకో request చేశావనుకో, నీకోసం ఇంకో, ఇంకో OS thread create చేస్తది"
wavs/-UMAP97L5q4_vocals00005017.wav,"అదే time లో నువ్వు ఇంకో request చేశావనుకో, నీకోసం ఇంకో OS thread create చేస్తదన్నమాట. Okay. ప్రతి request కి ఒక కొత్త OS thread create చేస్తది"
wavs/-UMAP97L5q4_vocals00005191.wav,ఇప్పుడు ఈ OS thread అనేది దగ్గర దగ్గరగా ఒక one MB space దాకా తీసుకుంటుంది. ఇప్పుడు మనకి ఏమనిపిస్తాది? Total గా one lakh requests ఒకేసారి వస్తాయి కాబట్టి one lakh OS threads create చేస్తది అనుకుంటాం
wavs/-UMAP97L5q4_vocals00005435.wav,Which is not completely true అనమాట. ఎందుకంటే ఒక OS thread అనేది one MB ఉంది. మన RAM ఏ eight GB. మన RAM eight GB లో ఆ OS threads అన్ని పట్టవు. అది first problem. Second problem ఏంటంటే పట్టినా కూడానూ
wavs/-UMAP97L5q4_vocals00005724.wav,చాలా ఎక్కువ OS threads create చేస్తే ఏమవుతది? మీ CPU అనేది చాలా ఎక్కువ threads ని జంపింగ్ చేయాల్సి వస్తది అనమాట. దానివల్ల context switching అనేది చాలా ఎక్కువ ఉంటది. సో చాలా ఎక్కువ time waste అనేది context switching లోనే పోతూ ఉంటది అనమాట
wavs/-UMAP97L5q4_vocals00006040.wav,"సో, అందుకే Tomcat ఏం చేస్తుందంటే thread pool అనే concept తెచ్చిందన్నమాట. ఈ thread pool లో ఏంటంటే max నువ్వు let's say ఒక four hundred threads మాత్రమే create చేసుకోగలవు OS అని చెప్పేస్తాదన్నమాట"
wavs/-UMAP97L5q4_vocals00006290.wav,సో ఇప్పుడు నువ్వు one lakh request చేసినా కూడానూ first four hundred OS threads మాత్రమే create చేస్తాయన్నమాట. మిగిలిన requests అన్నీ కూడానూ ఇలాగ Tomcat దగ్గర ఒక queue ఉంటది. ఆ queue లో నీ ninety nine thousand six hundred requests అనేవి అక్కడ wait చేస్తూ ఉంటాయి. ఓకే నా?
wavs/-UMAP97L5q4_vocals00006663.wav,ఇప్పుడు ఏమవుతది? Let's say ఇప్పుడు ఈ OS thread ఒక request ని తీసుకుంది. request ని తీసుకోగానే CPU దగ్గరికి వెళ్లి HTTP request ని create చేయించుకుంది. Okay నా? create చేయించుకున్న తర్వాత next ఏం చేయాలి? DB call చేయాలి. ఈ DB call చేయడం కోసం అది DB ని call చేస్తది. DB call చేసే time లో CPU పని అసలు ఏమీ ఉండదన్నమాట. So ఈ time లో నీ OS thread అనేది ఖాళీగా అలా ఉంటూ ఉంటది.
wavs/-UMAP97L5q4_vocals00007158.wav,"ఎప్పుడైతే DB call నుంచి response వచ్చేస్తాదో అప్పుడు ఏమవుతది password match చేస్తాది. Password match కి మళ్ళీ CPU అవసరం ఉంటది. సో, నీ OS thread అనేది CPU దగ్గరికి వెళ్లి instructions execute చేయించుకుంటుంది"
wavs/-UMAP97L5q4_vocals00007401.wav,దాంతోటి response creation. Response creation అప్పుడు కూడానూ OS thread కి CPU అవసరం ఉంటది. ఇదంతా అయిపోయిన తర్వాత నీకు ఆ response ఇచ్చేసి ఈ OS thread ఖాళీ అయిపోద్ది అనమాట.
wavs/-UMAP97L5q4_vocals00007626.wav,"ఖాళీ అయిపోయినప్పుడు ఈ ninety nine thousand six hundred లో ఒక request అనేది ఈ OS thread ని మళ్ళీ తీసుకుంటుందన్నమాట. సో, ఈ విధంగా మీ requests అన్నీ మెల్లమెల్లగా process అవుతూ ఉంటాయన్నమాట. ఇప్పుడు ఈ one lakh request complete అవడానికి rough గా ఎంత time తీసుకుంటుందనుకుంటాం? Let's say ఒక"
wavs/-UMAP97L5q4_vocals00007973.wav,"Hundred seconds తీసుకుందనుకుందాం. Hundred seconds లో ఈ one lakh requests process అవుతాయి. అసలు ఎందుకు ఈ hundred seconds తీసుకుంటుంది అని మనం observe చేస్తే, కొంత time ఏమో CPU time. అంటే ఏంటంటే, అసలు CPU లోని instructions అన్ని instructions execute చేయడానికి ఎంత time తీసుకుంటుంది?"
wavs/-UMAP97L5q4_vocals00008318.wav,Second time ఏం తీసుకుంటాది? DB call. DB call చేయడానికి ప్రతి request ఎల్సెమ్ తీసుకుంటాది. Third thing ఏంటి? Third thing ఏంటంటే context switching
wavs/-UMAP97L5q4_vocals00008487.wav,అసలు ప్రతిసారి ఇన్ని requests ఉంటున్నప్పుడు ఎంత context switching అనేది time waste అవుతుంది అనేది third. Fourth thing ఏంటి అంటే garbage collector
wavs/-UMAP97L5q4_vocals00008683.wav,ఇప్పుడు ఒక request రాగానే ఆ request కోసం కొన్ని objects create చేస్తున్నాం కదా. ఇప్పుడు ఆ request complete అయిపోగానే objects delete చేయాలి కదా. objects ని ఎవరు delete చేస్తారు? అది ఒక garbage collector delete చేస్తాదన్నమాట.
wavs/-UMAP97L5q4_vocals00008948.wav,సో ఆ garbage collector కూడా మళ్ళీ CPU కొంత time అవసరం వస్తది. సో ఈ విధంగా నీ hundred seconds అనేది ఈ విధంగా distribute అయి ఉంటదన్నమాట. ఇప్పుడు మనం ఏం చేద్దాం అంటే చాలా popular thing అయిన note చేసికెళ్దాం.
wavs/-UMAP97L5q4_vocals00009302.wav,Node JS లోని code అనేది ఈ విధంగా ఉంటాదన్నమాట. దీంట్లో మీరు observe చేస్తే verify password కి ఒక arguments ఉన్నాయి. దాని తర్వాత database query చేస్తున్నాను username check చేస్తున్నాను
wavs/-UMAP97L5q4_vocals00009557.wav,దాని తర్వాత passwords match చేస్తాను return చేస్తాను. similar code ఏ only thing ఏంటంటే syntax మారుతూ ఉంటది. ఇప్పుడు ఈ code అనేది internal గా ఎలా work అవుతది అంటే
wavs/-UMAP97L5q4_vocals00009763.wav,"ఈ విధంగా ఒక architecture ఉంటాదన్నమాట. దీంట్లో మీరు observe చేస్తే ఒక application layer ఉంది, ఒక OS layer ఉంది. Okay నా? ఇప్పుడు దీనికి మీరు ఒక request చేశారనుకోండి..."
wavs/-UMAP97L5q4_vocals00009967.wav,"Request చేయగానే ఆ request అనేది first మీ request ని ఒక queue లో పెట్టుకుంటాదన్నమాట. దాని తర్వాత మీరు ఇంకో request చేశారనుకోండి, దాన్ని కూడా ఈ queue లో పెట్టుకుంటాదన్నమాట. మీరు ఇంకో request చేస్తే దాన్ని కూడా queue లో పెట్టుకుంటాదన్నమాట. అలాగ మీరు చేసిన requests అన్నీ queue లో ఉంటాయి. దాని తర్వాత దీని దగ్గర Node.js లోని"
wavs/-UMAP97L5q4_vocals00010335.wav,"Java లాగా multiple OS threads ఉండవన్నమాట. ఒకటే OS thread ఉంటది. ఓకే నా? at the same time దీంట్లోని event loop అని ఒకటి ఉంటాదన్నమాట. ఈ event loop ఏం చేస్తదంటే, event loop అంటే మళ్ళీ మీరు confuse అయిపోకండా, just ఒక while loop లాంటిది అన్నమాట."
wavs/-UMAP97L5q4_vocals00010651.wav,"ఈ event loop ఏం చేస్తుందంటే, మీ request ని తీసుకుంటది. తీసుకుని ఒక OS thread కి assign చేస్తాది. OS thread ఏం చేస్తాది? CPU దగ్గరికి వెళ్లి మీ instructions execute చేసుకుంటాదన్నమాట. ఓకేనా? మన instructions ఏంటి? First http request create చేయడం, database ని call చేయడం."
wavs/-UMAP97L5q4_vocals00011013.wav,సో http request create చేసింది CPU తోని. దాని తర్వాత database call చేయాలి. Database call చేసే time లో CPU పని లేదని మనకు తెలుసు. ఆ time లో ఇది ఖాళీగా ఉంటాదన్నమాట
wavs/-UMAP97L5q4_vocals00011215.wav,"ఈ ఖాళీగా ఉండే time లో ఈ event loop ఏం చేస్తుందంటే ఖాళీగా నువ్వు OS thread ని ఎందుకు ఉంచుకోవడం, నువ్వు వెనక్కి వచ్చేయ్ అని చెప్పేసి అని దాన్ని RAM లో store చేస్తుందన్నమాట. దాన్ని closures అంటారు. ఈ time లో ఏం చేస్తుందంటే queue లో ఉన్న next request ని తీసుకొచ్చి OS thread కి ఇస్తుంది."
wavs/-UMAP97L5q4_vocals00011535.wav,"OS thread ఏం చేస్తది? మళ్ళీ CPU దగ్గరికి వెళ్లి instructions execute చేసుకుని ఇప్పుడు ఇది కూడా database ని call చేయాలంటే, ""నువ్వు మళ్ళీ OS thread ని ఎందుకు waste చేయను"" అని చెప్పేసని దాన్నే పట్టుకొచ్చేస్తుంది అన్నమాట."
wavs/-UMAP97L5q4_vocals00011750.wav,"క్యూ లో ఉన్న ఇంకో request ని OS thread కి ఇస్తుందన్నమాట. అది కూడా database call చేస్తుందనుకో, దాన్ని కూడా తీసేస్తుందన్నమాట. ఇప్పుడు మనం store చేసిన closures ఏంటి? అసలు ఆ request అనేది ఏ level వరకు execute అయ్యింది, దాంట్లో ఏ variables ఉన్నాయి, అలాగా ఆ request యొక్క state ని మనం ఇక్కడ closure లో store చేసుకుంటాం అన్నమాట."
wavs/-UMAP97L5q4_vocals00012152.wav,ఇప్పుడు ఎప్పుడైతే database call వచ్చేస్తదో అప్పుడు వీటిని మళ్ళీ మనం queue లో పెట్టేస్తాం. ఇప్పుడు event loop ఏం చేస్తది? ఈ request ని తీసుకొచ్చి మళ్ళీ OS thread కి assign చేస్తాది
wavs/-UMAP97L5q4_vocals00012378.wav,OS thread create చేసి దాని తర్వాత ఏమవుతది? Password matching దాని తర్వాత response creation. Password matching response creation అయిపోయిన తర్వాత మనం user కి response ఇచ్చేస్తాం.
wavs/-UMAP97L5q4_vocals00012580.wav,"దాని తర్వాత దీని response కూడా వచ్చిందనుకో database నుంచి, అది కూడా మళ్ళీ queue లోకి వెళ్తాది. దీని response కూడా database నుంచి వచ్చిందనుకోండి, ఇది కూడా queue లోకి వెళ్తాది"
wavs/-UMAP97L5q4_vocals00012750.wav,అలాగా ఇక్కడ మీరు observe చేస్తే ఒకటే OS thread ఒకటే event loop తోని మీ అన్ని requests sequential గా వెళ్తూ ఉంటాయి అన్నమాట
wavs/-UMAP97L5q4_vocals00012940.wav,"ఓకే నా, ఇక్కడ మీరు observe చేస్తే ఒకటే OS thread ని ఖాళీగా ఉంచకుండా effective గా node.js అనేది వాడుకుంటాదన్నమాట. ఇప్పుడు node.js లోని ఒకటే OS thread వల్ల problem కూడా ఉందన్నమాట. అదేంటి అంటే"
wavs/-UMAP97L5q4_vocals00013198.wav,పొరపాటున ఇప్పుడు మీరు ఒక request ఇచ్చారు. ఇప్పుడు ఈ request అనేది చాలా ఎక్కువ సేపు CP దగ్గర తీసుకుందనుకోండి
wavs/-UMAP97L5q4_vocals00013338.wav,"మీ ఒక్క OS thread ఇక్కడే stuck అయిపోయి ఉండిపోద్ది. Event loop ఇంకోదానికి assign చేయడానికి అసలు మీకు OS threads ఏ లేవన్నమాట. సో, అందుకే మరీ heavy CPU work ఉన్న దగ్గర మనం ఈ ఒక్కటే OS thread అనేది అంత effective కాదన్నమాట"
wavs/-UMAP97L5q4_vocals00013640.wav,ఇప్పుడు ఈ one lakh request ని process చేయాలంటే మనకి దగ్గర దగ్గరగా ఒక hundred seconds తీసుకుందనుకోండి
wavs/-UMAP97L5q4_vocals00013784.wav,"ఓకే నా, ఈ hundred seconds ఎక్కడ తీసుకుంటాది? first ఏమో object creation ఇదంతా, అదంతా CPU పని. next ఏమో DB calls"
wavs/-UMAP97L5q4_vocals00014007.wav,DB calls CPU పైన పని ఏం ఉండదు. దాని తర్వాత ఏమవుతది? దీంట్లో context switching అనేది లేదు. ఎందుకు? ఒకటే OS thread కాబట్టి context switching ఏ లేదు. Third thing ఏంటి అంటే garbage collector
wavs/-UMAP97L5q4_vocals00014282.wav,"దీంట్లో కూడా garbage collect ఉంటది. garbage collect ఏం చేద్దంటే, మీ request అయిపోయిన తర్వాత మీ request లో ఉన్న objects అన్నిటినీ కూడా delete చేస్తాదన్నమాట. దానికి కూడా CPU అవసరం ఉంటది."
wavs/-UMAP97L5q4_vocals00014505.wav,సో ఈ విధంగా Node.js అనేది మీ request ని handle చేస్తుంది. ఇప్పుడు అందరికీ favourite అయిన Python దగ్గరికి వెళదాం
wavs/-UMAP97L5q4_vocals00014748.wav,Python లో మీరు observe చేస్తే code అనేది ఇలా ఉంటాదన్నమాట
wavs/-UMAP97L5q4_vocals00014812.wav,దీంట్లో కూడాను email password ఇదంతా వస్తది database call చేస్తాను user లేకపోతే false return చేస్తాను passwords match చేస్తాను return చేస్తాను. so similar code ఏ only thing ఏంటంటే syntax మారుతది.
wavs/-UMAP97L5q4_vocals00015081.wav,"ఇప్పుడు Python యొక్క internal architecture మనం observe చేస్తే, అది కూడా somewhat similar Node.js లాగే ఉందన్నమాట. దాంట్లో కూడా ఒక event loop ఉంది, ఒక queue ఉంది, ఒక OS thread ఉంది, CPU ఉంది."
wavs/-UMAP97L5q4_vocals00015344.wav,సో ఇప్పుడు మీరు request ఇచ్చారనుకోండి ఆ request ని మనం note jass లాగానే first ఒక queue లో పెట్టుకుంటాం
wavs/-UMAP97L5q4_vocals00015501.wav,"ఇంకో request వస్తే దాన్ని కూడా queue లో పెట్టుకుంటాం. ఓకే నా? ఇప్పుడు event loop ఏం చేస్తుందంటే, మీ request ని OS thread కి assign చేస్తది. OS thread ఏం చేస్తది? CPU దగ్గర పట్టుకెళ్ళి మీ request ని process చేస్తది."
wavs/-UMAP97L5q4_vocals00015781.wav,"ఇప్పుడు నీ request పొరపాటున database call చేయాలనుకో అప్పుడు అది ఏం చేద్దంటే, ""నువ్వు OS thread దగ్గర ఎందుకున్నావ్, నువ్వు వెనక్కి వచ్చేయమ్మా"" అని చెప్పేసని దాన్ని RAM లో store చేసుకుంటది."
wavs/-UMAP97L5q4_vocals00016011.wav,Python దీన్ని ఏమంటది అంటే coroutines అంటది అనమాట. మీరు observe చేస్తే ఇదే దాన్ని Node.js ఏమో closures అంటుంది Python అనేది coroutine అంటది
wavs/-UMAP97L5q4_vocals00016216.wav,"Coroutine కూడా same అంతే. ఒక request ఎంత వరకు అయ్యింది అని దాని state ని ఇక్కడ store చేసుకుంటాం అనమాట. ఇది మరీ ఎక్కువ size తీసుకోదు. OS thread అనుకోండి, OS thread one MB size తీసుకుంటది. కానీ ఈ coroutines అంత size తీసుకోవు అనమాట."
wavs/-UMAP97L5q4_vocals00016512.wav,"సో ఇప్పుడు దాని తర్వాత ఏం చేస్తది event loop ఈ request తీసుకుని దాన్ని process చేస్తది. ఇప్పుడు ఈ request response వచ్చింది అనుకోండి, మళ్ళీ అది అలాగ నీ loop లోకి వెళ్తది. సో ఈ విధంగా same Node.js లాగ ఇది కూడా work అవుద్ది అనమాట."
wavs/-UMAP97L5q4_vocals00016765.wav,సో ఇక్కడ కూడాను మీ one lakh request ని process చేయడానికి మీకు దగ్గిర్ దగ్గిర్ గా ఆ ఒక three hundred seconds తీసుకుంటది అనుకుందాం
wavs/-UMAP97L5q4_vocals00016964.wav,మీకు doubt రావచ్చు three hundred seconds ఏంటి node.js లాగే అంటున్నారు కదా node.js కన్నా ఎక్కువ సేపు ఎందుకు తీసుకుంటుంది అని చెప్పేసి అని. ఈ three hundred seconds మనం ఎందుకు తీసుకుంటున్నాం? first ఏమో object creation
wavs/-UMAP97L5q4_vocals00017229.wav,అంతేనా object creation దగ్గర ఎక్కువ CPU work ఉంటది. దాని తర్వాత ఏమవుతది DB calls DB calls అన్నిటికి fix అని దాని తర్వాత garbage collector garbage collector దీంట్లో కూడా ఉంది.
wavs/-UMAP97L5q4_vocals00017471.wav,ఓకే నా కాకపోతే ఇక్కడ ఎక్కువ time ఎక్కడ తీసుకుంటది అంటే object creation దగ్గర తీసుకుంటది అనమాట
wavs/-UMAP97L5q4_vocals00017600.wav,"ఎందుకు అంటే Node JS గాని Python గాని ఇవన్నీ ఏంటి అంటే, ఇవన్నీ static languages కాదు. Static languages కాదంటే అర్థం ఏంటంటే, for example ఇప్పుడు Java లో నేను int I equals to four అన్నాననుకో, దానికి ముందే చెప్పేస్తాను ఇది ఒక integer అని చెప్పేస్తాను."
wavs/-UMAP97L5q4_vocals00017947.wav,దీని వల్ల ఏంటి అంటే అది RAM లోని అంతే స్టో-- స్పేస్ తీసుకుంటది. అదే ఇప్పుడు నేను మామూలుగా జా-JavaScript లో వీటిలో ఏం చేస్తాను var i equal to four అంటాను
wavs/-UMAP97L5q4_vocals00018151.wav,"ఓకే నా, అది అసలు integer అని చెప్పేసని run time లో తెలుస్తాది. అంతే తప్ప ముందే తెలీదు అనమాట అది ఒక integer అని చెప్పేసని"
wavs/-UMAP97L5q4_vocals00018328.wav,"సేమ్ Python లో కూడా ఇలాగే ఉంటాదట. Python లో కూడా ముందే అది integer ఆ లేకపోతే string ఆ ఏంటా అని చెప్పేసి అని run time లో తెలుస్తాది. సో, దీనివల్ల Java లో ఇది four bytes ఇస్తుందనుకోండి Node JS లో గాని Python లో గాని దగ్గర దగ్గర twenty కన్నా ఎక్కువ bytes తీసుకుంటాదన్నమాట."
wavs/-UMAP97L5q4_vocals00018676.wav,సో మీ object creation కి ఎక్కువ time తీసుకుంటాది. ఎందుకంటే object లో ఏ data types ఉన్నాయని మనం ముందే తెలియకపోవడం వల్ల ఎక్కువ time తీసుకుంటాది.
wavs/-UMAP97L5q4_vocals00018886.wav,మరి మీకు అనిపించొచ్చు నోడ్ JS పైథాన్ ఒకే time తీసుకోవాలి కదా రెండు static languages కాదు కదా అని చెప్పేసి అని
wavs/-UMAP97L5q4_vocals00019012.wav,"కాకపోతే Node.js recent versions లో వాడు కొన్ని optimizations చేయడం వల్ల Node.js అనేది Python కంటేనూ better గా object ని handle చేస్తదన్నమాట. So, ఈ విధంగా Python అనేది మీ request ని handle చేస్తుంది."
wavs/-UMAP97L5q4_vocals00019363.wav,"ఇప్పుడు మనం చాలా famous అయినా Go language కి వద్దాం. Go language లో మీరు observe చేస్తే దీంట్లోనేమో email, password ఉంటది. దాని తర్వాత మనం database query చేస్తాం. Database query చేసిన తర్వాత same code ఏ ఉంటది. పెద్ద తేడా ఏం ఉండదు."
wavs/-UMAP97L5q4_vocals00019660.wav,"Only thing అంటే syntax మారుతూ ఉంటది. ఇప్పుడు Go దీన్ని internal గా ఎలా చేస్తుంది అని observe చేస్తే, దీంట్లో ఇలాంటి architecture ఉంటదన్నమాట"
wavs/-UMAP97L5q4_vocals00019819.wav,ఇదొక OS layer ఇది application layer. ఓకేనా? ఇప్పుడు మీకు ఒక request రాగానే Go మీ కోసం ఏం చేస్తది?
wavs/-UMAP97L5q4_vocals00020001.wav,"ఒక coroutine create చేస్తదనమాట. దాన్ని coroutine అంటారు. మీ request ని first ఇక్కడ దాస్తది. దాని తర్వాత మీరు ఇంకో request చేశారనుకోండి, దానికోసం ఇంకో coroutine చేస్తదనమాట. మీరు ఇంకో request చేశారనుకోండి, మీకోసం ఇంకో coroutine create చేస్తది."
wavs/-UMAP97L5q4_vocals00020299.wav,అలాగే మీరు ఎన్ని request చేస్తే అన్ని coroutines create చేస్తాది. ఈ coroutines అన్నిటికి పెద్ద space ఏం తీసుకోదు అనమాట few KBస్ లోనే ఉంటాది.
wavs/-UMAP97L5q4_vocals00020456.wav,"ఇప్పుడు ఇక్కడ మీరు observe చేస్తే OS threads ఉన్నాయి. Golang యొక్క philosophy ఏంటి అంటే, see Node.js ఏమో ఒకటే OS thread ఉంది. ఒకటే OS thread ఉండటం వల్ల"
wavs/-UMAP97L5q4_vocals00020725.wav,Request fast గా handle చేస్తుంది కానీ CPU heavy work వస్తే కొంచెం దెబ్బ అయిపోతుంది. అదే ఇప్పుడు మీరు Java లో observe చేస్తే Java లో ఎక్కువ OS threads ఉన్నాయి. ఓకే నా! ఎక్కువ OS thread ఉండడం వల్ల context switching అనేది ఎక్కువ అయిపోతుంది.
wavs/-UMAP97L5q4_vocals00021005.wav,"సో Golang ఏం చేస్తుంది అంటే, నేను మరీ ఎక్కువ OS threads create చేసుకోను. నేను Java నుంచి కొంత తీసుకుంటాను, Node.js నుంచి కొంత inspiration తీసుకుని, నేను మరీ ఎక్కువ OS threads handle చేయను. కొన్ని OS threads ఏ పెట్టుకుంటుందన్నమాట"
wavs/-UMAP97L5q4_vocals00021302.wav,దగ్గర దగ్గర let's say ఇదొక four to five OS threads అనేది create చేసుకుంది
wavs/-UMAP97L5q4_vocals00021409.wav,"ఓకే నా, ఇక్కడ మీరు observe చేస్తే OS scheduler తో పాటు ఇక్కడొక scheduler ఉందన్నమాట application layer లో, ఓకే నా. దాన్నే Go scheduler అంటారన్నమాట. ఈ Go scheduler interesting గా ఏం చేస్తుందంటే, మీ request ఉంది కదా, మీ request ఒక coroutine ఉంది. దీన్ని coroutine అంటాం. ఇక్కడ మీరు observe చేస్తే ఒక Go scheduler ఉందన్నమాట."
wavs/-UMAP97L5q4_vocals00021798.wav,"Go schedule కి మంచి interesting పని ఉంటుందన్నమాట. అదేం చేస్తదంటే, మీ request ని తీసుకుంటది. మీ request ని తీసుకుని మీకంటూ ఒక OS thread ని assign చేస్తది"
wavs/-UMAP97L5q4_vocals00021983.wav,అలాగ మీ request ని తీసుకుంటది. తీసుకుని ఇంకో voice thread ని మీకు assign చేస్తాది. దాని తర్వాత ఇంకో request ని తీసుకుని ఇంకో voice thread ki assign చేస్తాది.
wavs/-UMAP97L5q4_vocals00022173.wav,"అసైన్ చేసిన తర్వాత పొరపాటున let's say మీరు ఒక database కాల్ చేస్తున్నారనుకోండి, database కాల్ చేసినప్పుడు ఇదనుకుంటది database కాల్ చేసినప్పుడు ఎందుకు దీనికి OS thread waste అని చెప్పేసి అని మీ కోడ్ ఇదంతా తెచ్చుకొని మళ్ళీ store చేసుకుంటదన్నమాట. ఈ timeలో ఇంకో request వచ్చిందనుకోండి"
wavs/-UMAP97L5q4_vocals00022517.wav,"దానికోసం కూడా ఒక coroutine create చేస్తాం కదా. ఆ coroutine కి assign చేస్తాం కదా OS thread ని. so ఇక్కడ మీరు observe చేస్తే scheduler పని ఏంటి అంటే మీ దగ్గర కొన్ని coroutines ఉంటాయి, మీ దగ్గర at the same time"
wavs/-UMAP97L5q4_vocals00022797.wav,"OS threads ఉంటాయి. ఇప్పుడు ఏ OS thread కి ఏ coroutine వెళ్ళాలా అని చెప్పేసి అది figure out చేస్తది అనమాట. Coroutine అంటే మళ్ళీ ఏది అనుకోవద్దు అది just object లాంటిది అది. ఆ object లో ఏంటి అంటే, మీ request యొక్క state ని మనం store చేసుకుంటూ ఉంటాం. ఏ లెవెల్ వరకు execute అయ్యింది, దాంట్లో ఏ variables ఉన్నాయి, అవన్నీ store చేసుకుంటాం."
wavs/-UMAP97L5q4_vocals00023139.wav,సో ఇప్పుడు మీరు observe చేస్తే మీ Go లోని మీరు one lakh request చేసినా కూడానూ ఆ one lakh request ని అది handle చేయగలదు అనమాట. ఎందుకంటే మనం చాలా one lakh coroutines create చేసుకుంటాం
wavs/-UMAP97L5q4_vocals00023396.wav,"Coroutine యొక్క size అనేది ఎక్కువ KB ఏం ఉండదు. కొన్ని KBస్ లో ఉంటది. ఆ KBస్ లో ఉండటం వల్ల అన్ని coroutines దీంట్లో fit అయిపోతాయన్నమాట. fit అయిపోయిన తర్వాత మీ go scheduler ఏం చేస్తుందంటే, మీ coroutines ని మీ OS threads కి map చేస్తూ ఉంటది."
wavs/-UMAP97L5q4_vocals00023682.wav,ఓకే నా? ఈ విధంగా Go అనేది మీ request ని handle చేస్తది. ఇప్పుడు one lakh request మీరు చేస్తే
wavs/-UMAP97L5q4_vocals00023860.wav,ఆ one lakh request కి దగ్గర దగ్గర let's say మనం ఒక hundred seconds తీసుకుంటాది అనుకుందాం. ఈ hundred seconds ఎక్కడ పోతది? మీరు observe చేస్తే first object creation లో పోతది
wavs/-UMAP97L5q4_vocals00024115.wav,అంతేనా? Object creation లో కొన్ని పోతది. Next ఏమవుద్ది? Database calls లో పోతది. Next ఏమవుతది? Next ఏమవుతది? Garbage collector లో కొంచెం పోతది.
wavs/-UMAP97L5q4_vocals00024328.wav,"ఓకే నా, ఈ hundred seconds overall గా దీంట్లో పోతది. ఇప్పుడు మీరు observe చేస్తే object creation అనేది Node.js కన్నా Python కన్నా ఇది fast గా ఉంటది. ఎందుకు అంటే Go అనేది static language."
wavs/-UMAP97L5q4_vocals00024580.wav,"Dynamic language కాదు static language Java లాగన్నమాట. So మనం ముందే data type ని ముందే fix చేస్తాం. ఇంకా, ఇంకా ఇక్కడ depth కి వెళ్ళచ్చు but మీకు కొంచెం simplify చేసి చెప్పేస్తున్నాను. ఈ విధంగా Golang అనేది మీ request ని process చేస్తదన్నమాట. Golang లో multiple OS threads ఉండడం వల్ల CPU heavy works కూడా అవి బాగానే handle చేస్తాయన్నమాట"
wavs/-UMAP97L5q4_vocals00024983.wav,ఇప్పుడు మీకు అనిపించవచ్చు ఇంకెన్ని languages రా బాబు అని చెప్పేసి అని కాకపోతే ఇంకొక్క language ఉంది అదేంటి Rust
wavs/-UMAP97L5q4_vocals00025189.wav,మనం ఈ మధ్యన popular గా వింటున్న language ఇది. మనం ఒకసారి Rust లోకి వెళ్లి observe చేస్తే Rust లో మీ code అనేది ఈ విధంగా ఉంటది
wavs/-UMAP97L5q4_vocals00025363.wav,దీంట్లో మీరు observe చేస్తే verify password ఉంటది email password వస్తది SQL query చేస్తాము query చేసిన తర్వాత response వస్తది verify చేస్తాం. ఇదంతా regular thing ఏ
wavs/-UMAP97L5q4_vocals00025576.wav,ఓకే దీంట్లోని syntax మారడం తప్ప మొత్తం అంతా regular thing ఏ. ఇప్పుడు rust యొక్క internal architecture observe చేస్తే some అది కూడా కొంచెం golang లాగే ఉంటాది అనమాట. ఓకే నా? మీకు ఒక request వచ్చింది అనుకోండి
wavs/-UMAP97L5q4_vocals00025822.wav,అంటే Rust యొక్క basic thing Rust యొక్క default thing కాదు Rust లోని ఆ Tokyo something ఏదో ఒక library ఉంటాదంట. ఆ library వాడితే దీనికి async capabilities వస్తాయన్నమాట Rust కి
wavs/-UMAP97L5q4_vocals00026042.wav,ఐసి క్యాబిన్స్ లాగా అనేది ఏం చేస్తదంటే మీరు ఒక request చేశారనుకోండి మీ కోసం co-routine లాగా ఇలాగ ఒక object create చేసుకుంటాదన్నమాట. అలా మీరు ఎన్ని request చేస్తే అన్నిటికీ ఒక co-routine లాగా ఒక object create చేస్తుంది
wavs/-UMAP97L5q4_vocals00026302.wav,"ఇప్పుడు ఒక scheduler కూడా దాంట్లో ఉంటాదన్నమాట. Okay నా? అలానే ఒక OS scheduler ఉంటది OS threads కూడా ఉంటది. ఇప్పుడు as usual గా same ఈ scheduler పని ఏంటి అంటే, ఒక co routine తీసుకుని దాన్ని ఇంకోదానికి assign చేస్తాదన్నమాట. ఒక co routine తీసుకుని దాన్ని OS thread కి assign చేస్తాది."
wavs/-UMAP97L5q4_vocals00026653.wav,"Database call అవుతున్న కొద్ది మళ్ళీ ఆ query ని తెచ్చుకొని RAM లో store చేసుకుంటాది. So, ఈ విధంగా మీ one lakh request ని similar to Rust-- similar to Go లాగా అది handle చేస్తాది. Rust అనేది ఈ one lakh request ని handle చేయడం కోసం అది hundred seconds కన్నా తక్కువే తీసుకుంటాది అనమాట"
wavs/-UMAP97L5q4_vocals00027002.wav,Let's say ఒక ninety eight seconds తీసుకుందనుకుందాం. ఓకే నా? ఇప్పుడు ఈ ninety eight seconds దేని వల్ల ఉంటాది? ఒకటి object creation
wavs/-UMAP97L5q4_vocals00027176.wav,రెండోది ఏమవుద్ది అంటే DB call. ఓకే. మూడోది అసలు garbage collect అనే concept దీంట్లో ఉండదన్నమాట
wavs/-UMAP97L5q4_vocals00027380.wav,Garbage collector అంటే Rust లో ఉండదు. ఎందుకంటే Rust మనం code రాస్తున్నప్పుడే memory management అనేది ముందే fix అయిపోతుంటదన్నమాట. నువ్వు code compile చేస్తున్న time లోనే నీకు చాలా మట్టు memory management ఉంటది. అంతే తప్ప నీకు వేరేగా garbage collector అంటూ ఉండదు.
wavs/-UMAP97L5q4_vocals00027683.wav,ఈ password ఇవన్నీ verify చేసిన వెంటనే నీ-- నీ objects అనేవి memory నుంచి delete అయిపోతాయి Rust లోని. ఓకే నా? అందుకే Rust అనేది code రాస్తున్నప్పుడు చాలా జాగ్రత్తగా ఉండాలి but code run అయ్యేటప్పుడు మాత్రం చాలా fast గా ఉంటాదన్నమాట. So ఈ విధంగా Rust అనేది మీ one lakh request ని handle చేస్తాదన్నమాట.
wavs/-UMAP97L5q4_vocals00028035.wav,At the same time Rust అనేది చాలా optimizations compile time లోనే చేసేస్తది అన్నమాట memory management ఇదంతాను
wavs/-UMAP97L5q4_vocals00028166.wav,సో దీని వల్ల కోడ్ run చేసినప్పుడు చాలా fast గా ఉంటది. సో ఇట్లా మీరు observe చేస్తే ఈ విధంగా మీరు ఒక API call authentication లాంటి API call ఇస్తే different different languages అనేవి internally ఇలా work అవుతది అనమాట. ఇప్పుడు ప్రతి language ఎంత time తీసుకుంటది అనేది మనం దాన్ని steps లా breakdown చేసుకుంటే మనకి easy గా దాన్ని figure out చేయొచ్చు అనమాట.
wavs/-UMAP97L5q4_vocals00028561.wav,"సో, ఈ concepts వాడే for example కొంతమంది load balancer create చేయడం కోసం Node.js వాడుతారు. లేకపోతే heavy CPU applications build చేయడం కోసం Java గాని Rust గాని Go గాని ఇలాంటివి వాడుతుంటారు"
wavs/-UMAP97L5q4_vocals00028782.wav,ఇప్పుడు మీ code కి మీరు ఏ language వాడాలి అని figure out చెయ్యాలి అంటే first అసలు మీ code లో ఎలాంటి instructions ఉన్నాయని మీరు figure out చెయ్యాలన్నమాట
wavs/-UMAP97L5q4_vocals00028941.wav,"మీ, మీ application అనేది IO heavy ఆ, లేకపోతే CPU heavy ఆ, లేకపోతే memory heavy ఆ? ఎలాంటి type of instructions"
wavs/-UMAP97L5q4_vocals00029100.wav,"ఇప్పుడు instructions ని different languages ఎలా handle చేస్తది అని మీరు observe చేస్తే, ఏ language మీకు better గా suit అవుద్ది అని మీకు easy గా identify చేయొచ్చన్నమాట"
wavs/-UMAP97L5q4_vocals00029281.wav,Thanks for watching the video till now. Bye.
wavs/RFAIqyP6mZc_vocals00000000.wav,Two thousand eighteen ఆ time కల్లాను Facebook అనేది world లోనే ఒక biggest social network అన్నమాట. కాకపోతే అది initially ga two thousand five లోనే ఒక college లోనే start చేశారు. ఆ time లో వాళ్ళు అప్పుడు popular గా ఉన్న MySQL database start చేశారన్నమాట.
wavs/RFAIqyP6mZc_vocals00000275.wav,ఇప్పుడు over the years peta bytes of data వచ్చేస్తున్నాయి అన్నమాట. ఎందుకు? All over the world అందరూ Facebook వాడటం మొదలు పెట్టారు కాబట్టి. ఇప్పుడు ఈ peta bytes of data store చేయడానికి వాళ్ళు ఎన్నో thousands of MySQL servers maintain చేసేవారు అన్నమాట.
wavs/RFAIqyP6mZc_vocals00000554.wav,"ఈ thousands of MySQL servers cost అనేది కొన్ని కోట్లోనే ఉండేది. Maybe ఒక three hundred crores, four hundred crores కూడా ఉండొచ్చు. ఇప్పుడు Facebook అనుకుంది, ""ఏంట్రా ఇంత ఖర్చు పెడుతున్నాము? దీన్ని తగ్గించలేమా?"" అని చెప్పేసి అనుకున్నారన్నమాట. ఇప్పుడు వాళ్ళ దగ్గర ఉన్న smartest engineer అంతా కలిసి ఏం చేశారంటే MySQLలోని కొన్ని problems identify చేశారన్నమాట. ఆ problems వల్లే వాళ్ళకి ఇంత cost వస్తుందని identify చేశారు."
wavs/RFAIqyP6mZc_vocals00000964.wav,"ఇప్పుడు వాళ్ళు ఏం చేశారంటే దానికి alternate గా ఒక solution తయారు చేశారు. అదే my rocks engine అన్నమాట. ఈ my rocks engine వల్ల వాళ్ళకి almost sixty percent of cost reduction వచ్చిందన్నమాట. అంటే దగ్గర దగ్గరగా వాళ్ళు initially four hundred crores pay చేస్తే ఇప్పుడు ఒక one sixty, one forty crores కి వచ్చిందన్నమాట cost అనేది."
wavs/RFAIqyP6mZc_vocals00001335.wav,"సో వాళ్ళు చేసిన optimization అంతటి గురించి MyRocks మీద ఒక internet లో ఒక blog post వాళ్ళు post చేశారన్నమాట. సో ఈ video లో మనం ఏం చేస్తున్నాం అంటే అసలు Facebook అనే వాళ్ళు MySQL లో ఎలాంటి problems identify చేశారు, ఆ problems ని MyRocks use చేసి ఎలా solve చేశారు, దాని architecture ఏంటి అనే విషయాలు ఈ video లో discuss చేద్దాం. సో late చేయకుండా video లోకి వెళ్దాం."
wavs/RFAIqyP6mZc_vocals00001790.wav,MySQL లో problems తెలుసుకునే ముందు అసలు MySQL లోని basics కొంచెం తెలుసుకుందాం అన్నమాట. మనందరికీ తెలుసు MySQL లో table ఉంటాది. ఆ table లో మన rows అన్ని store అవుతాయి.
wavs/RFAIqyP6mZc_vocals00002017.wav,"కాకపోతే ఈ table అనేది చిన్న చిన్న pages కింద breakdown అయి ఉంటాదన్నమాట. ప్రతి page లోని ఒక 16 KB దాకా data store చేసుకోవచ్చు. సో, మీ rows అనేవి exact గా ఈ pages లోనే store అవుతది."
wavs/RFAIqyP6mZc_vocals00002273.wav,"ఇది ఒక basic understanding అనమాట. ఇప్పుడు మనం ఏం చేద్దాం అంటే, అసలు MySQL లోని internal గా rights ఎలా work అవుతాయో తెలిస్తే, అసలు MySQL లో ఉండే basic problems ఏంటో మనం identify చేయొచ్చు."
wavs/RFAIqyP6mZc_vocals00002589.wav,"సో ఇక్కడ మీరు observe చేస్తే MySQL లోని internal architecture అనేది ఇలా ఉంటాదన్నమాట. ఇక్కడ ఒక MySQL server ఉంది, ఒక OS layer ఉంది, అలాగే ఒక డిస్క్ layer ఉంది"
wavs/RFAIqyP6mZc_vocals00002797.wav,"ఇప్పుడు నువ్వొక write చేద్దాం అని వచ్చావనుకో, నీ write అనేది first ఏమవుతది ఒక query parser ఉంటది. ఈ query parser అనేది నీ query అసలు ఏంటి అని అర్థం చేసుకుంటది."
wavs/RFAIqyP6mZc_vocals00003028.wav,"తర్వాత query planner ఉంటది. ఆ query planner ఏం చేస్తది, optimize అని వాడి అసలు నీ query ని ఎలా plan చేయొచ్చు అని చెప్పేసి అని plan చేస్తది. plan చేయగానే next దాని తర్వాత నుంచి InnoDB లోకి enter అయిపోతాం అనమాట."
wavs/RFAIqyP6mZc_vocals00003307.wav,ఇప్పుడు InnoDB ఏం చేస్తుందంటే B-tree indexing వాడతది అనమాట. ఈ B-treeలోనే exact గా మనం ఇందాక pages అన్నాం చూడండి. ఆ pages అనేవి B-treeలోనే store అయి ఉంటాయనమాట.
wavs/RFAIqyP6mZc_vocals00003508.wav,సో first ఏం చేస్తదంటే B-tree లోకి enter అయ్యి మీ page ని figure out చేస్తదన్నమాట. మీ row అనేది ఏ page లో ఉంది అని చెప్పేసి.
wavs/RFAIqyP6mZc_vocals00003679.wav,figure out చేసి ఆ page మొత్తాన్ని change చేసి అది buffer pool లో store చేస్తుందన్నమాట. so మీ page అనేది buffer pool లో ఉంది. buffer pool లో store అంటే ఏంటి? ఇక్కడ ఒక RAM అన్నమాట buffer pool is nothing but ఒక RAM అన్నమాట.
wavs/RFAIqyP6mZc_vocals00003955.wav,ఇప్పుడు RAM లో store చేసిన తర్వాత data అనేది అంత correct కాదు కదా. ఎందుకంటే current పోతే data పోతది కదా. So అందుకు మనం safety కింద data ని redo log లో కూడా store చేసుకుంటాం అనమాట.
wavs/RFAIqyP6mZc_vocals00004192.wav,"ఓకే నా, so buffer pool లో store చేసాం redo log లో store చేసాం. రెండు store చేసిన తర్వాత user కి అనేదానికి response ఇచ్చేస్తాం. so నువ్వు ఇప్పుడు observe చేస్తే, నీ data అనేది buffer pool లో ఉంది redo log లో ఉంది. కాకపోతే ఇంకా డిస్క్ లోని data table లోకి ఇంకా ఎళ్ళలేదన్నమాట"
wavs/RFAIqyP6mZc_vocals00004519.wav,సో MySQL లోని checkpoint అనే concept ఉందన్నమాట. Checkpoint ఏంటంటే ఒక specific interval of time లోని నీ buffer pool ఉన్న data అనేది actual data table లోకి వెళ్తది అన్నమాట
wavs/RFAIqyP6mZc_vocals00004738.wav,"buffer pool ఏంటా ఉంది? నీ row ఏ page లో ఉందో ఆ page ఉందన్నమాట. ఎప్పుడైనా MySQL లోని నువ్వొక row change చేశావనుకో, ఆ row అనేది exact గా data table లోకి వెళ్లి change అవ్వదు"
wavs/RFAIqyP6mZc_vocals00004986.wav,"ఆ row అసలు ఏ page లో ఉంది, ఆ page అనేది data table దగ్గరికి వెళ్లి మళ్ళీ మొత్తం update అవుద్ది అనమాట. So, నువ్వొక two KB ఒక row రాసినా కూడానూ ఆ two KB row అనేది sixteen KB page లో ఉంటది. So, sixteen KB మొత్తం వెళ్ళి డిస్క్ లో write అవుద్ది అనమాట"
wavs/RFAIqyP6mZc_vocals00005352.wav,ఓకే నా? ఇక్కడ right అవుతుంది బానే ఉంది కదా but still ఇక్కడ ఒక problem ఉందన్నమాట. ఏంటంటే disk అంట అది అరే బాబు నేను at any time point of time four KB data మాత్రమే
wavs/RFAIqyP6mZc_vocals00005628.wav,"atomic గా రాయగలను అంటే ఏంటి? అంటే ఏంటంటే, నువ్వొక four KB data నాకు రాయమన్నావ్ అనుకో current పోయినా కూడా దాన్ని correct గా రాసిగలను. ఇప్పుడు నువ్వు sixteen KB data వేస్తున్నావ్"
wavs/RFAIqyP6mZc_vocals00005870.wav,"current మధ్యలో పోయిందనుకో, నీ data మొత్తం inconsistent state లో ఉంటది. ఎందుకు? నీ దగ్గర already ఒక page ఉంది. ఒక"
wavs/RFAIqyP6mZc_vocals00006024.wav,"ఓకే నా, ఆ page లో already కొంత data ఉంది. ఇప్పుడు నువ్వేమంటున్నావు? ఆ page ని కొత్త data తో update చేయమని చెప్తున్నావ్."
wavs/RFAIqyP6mZc_vocals00006184.wav,సో కొంత పాత data కొంత కొత్త data ఉండిపోతది. సో page inconsistent ఉంటాది అంటారన్నమాట. సో దానికోసమే InnoDB ఏం చేసిందంటే double write buffer అనే concept తెచ్చిందన్నమాట.
wavs/RFAIqyP6mZc_vocals00006421.wav,ఈ double write buffer లో ఏం చేస్తుందంటే direct గా data table కి రాయకుండా first double write buffer లో ఈ sixteen KB data మొత్తం sequential గా రాసేస్తుందన్నమాట
wavs/RFAIqyP6mZc_vocals00006639.wav,"రాసిన తర్వాత next అప్పుడు data table లో రాయడానికి అది attempt చేస్తది. ఇప్పుడు so ఇక్కడ double write buffer వల్ల benefit ఏంటంటే, ఇప్పుడు నువ్వు data table కి రాస్తున్నావు data sixteen KB data రాసేటప్పుడు మధ్యలో power పోయింది. power పోగానే నీ page అనేది inconsistent state లో ఉంటది"
wavs/RFAIqyP6mZc_vocals00006990.wav,"అప్పుడు ఆ page నీకు మళ్ళీ కావాలి కదా రాసుకోవడానికి, ఆ page ఎక్కడ ఉంటది? నీ double write buffer లో ఉంటది. నువ్వు double write buffer లో already data ని store చేసుకోవడం వల్ల నువ్వు దాన్ని ఎప్పుడైనా వెనక్కి తెచ్చుకొని మళ్ళీ data-- మళ్ళీ data type లోని store చేసుకోవచ్చు."
wavs/RFAIqyP6mZc_vocals00007318.wav,"Overall గా ఈ విధంగా MySQL లోని re-writes అనేవి work అవుతాయన్నమాట. So, నీకు ఇక్కడ next one అనిపించొచ్చు, ఆ ఏముంది దాంట్లో అని writes బానే అవుతున్నాయి కదా దీంట్లో ఏం problem నీకు అనిపించొచ్చు. కానీ ఇక్కడ నువ్వు observe చేస్తే first problem ఏంటి అంటే write amplification"
wavs/RFAIqyP6mZc_vocals00007633.wav,అంటే ఏంటి అంటే అసలు ఏం రాద్దాం అనొచ్చు? నువ్వొక two KB ఒక data రాద్దాం అనొచ్చు. ఒక row యొక్క data రాద్దాం అనొచ్చు. కానీ ఇక్కడ ఏమవుతుంది two KB data రాయాలి అంటే first redo log రాయాల్సి వస్తుంది. దాని తర్వాత double write buffer రాయాల్సి వస్తుంది. ఆ తర్వాత data tableలో sixteen KB data రాయాల్సి వస్తుంది.
wavs/RFAIqyP6mZc_vocals00008067.wav,"Okay, double write buffer ఏమో sixteen KB ఉంటది. ఈ redo log ఏమో let's say ఒక two KB ఉందనుకో. so మొత్తం నీకు thirty four KB నీ data disk లో రాస్తున్నావ్ అన్నమాట"
wavs/RFAIqyP6mZc_vocals00008326.wav,"Thirty four KB, two KB రాద్దాం అంటే ఇది first problem అనమాట. ఎందుకు first problem? ఇప్పుడు Facebook కి ఇది ఎందుకు problem? Facebook దగ్గర petabytes of data ఉంటదనమాట."
wavs/RFAIqyP6mZc_vocals00008568.wav,For example ఒక simple గా one petabyte data రాయాలి అంటే MySQL ప్రకారం into twenty times data దాంట్లో store అయ్యుంటది అనమాట one petabyte రాయాలంటే
wavs/RFAIqyP6mZc_vocals00008763.wav,"ఇప్పుడు MySQL దగ్గర ఎన్నో petabytes ఉంటాయి. సో, దాని కోసం ఆ data మొత్తం store చేయడానికి ఎన్నో MySQL servers కావాలనమాట. ఇది first problem. Second problem ఏంటి అంటే hardware wear and tear అన్నమాట."
wavs/RFAIqyP6mZc_vocals00009043.wav,అంటే ఏంటంటే ఇప్పుడు మీకు ఏమవుతుంది మనం చిన్న write రాద్దామన్నా మన డిస్క్ లోకి వెళ్లి చాలా ఎక్కువ writes అయిపోతున్నాయన్నమాట. ప్రతి hardware లోకి నువ్వు
wavs/RFAIqyP6mZc_vocals00009292.wav,"కొన్ని cycles ఉంటాయి అనమాట. ఇప్పుడు మీది డిస్క్ అనుకోండి, ఈ డిస్క్ లో కూడాను data అనేది ఎక్కడో ఒక సా-దగ్గర store అవుద్ది కదా. ఆ store కొన్ని electrical signals వల్ల data అంతా మీరు store చేస్తున్నారు"
wavs/RFAIqyP6mZc_vocals00009531.wav,"ఇప్పుడు ప్రతి hardwareకి కొన్ని write cycles ఉంటాయి అన్నమాట. అంటే ఏంటంటే అది maximum ఇన్ని writes ఏ చేయగలదు అని చెప్పేసి. నువ్వేం చేస్తున్నావ్ 2KB data కోసం కూడా 34KB రాస్తున్నావ్. అంటే, అంటే data ని రాస్తూనే ఉన్నావ్ అన్నమాట."
wavs/RFAIqyP6mZc_vocals00009827.wav,సో దీని వల్ల ఈ hardware cycles అన్నీ వేరేలాగా exhaust అయిపోతాయన్నమాట. సో ఇలా ఎక్కువ hardware cycles అయిపోవడం వల్ల problem ఏంటంటే MySQL బోల్డ్ డిస్క్ లో data మొత్తం store చేస్తుంది. ఇప్పుడు ఈ డిస్క్స్ అన్నీ replace చేయాల్సి వస్తుందన్నమాట. లేకపోతే చాలా ఎక్కువ hardware cycles ఉన్న డిస్క్ లు కొనుక్కోవాల్సి వస్తుంది which are very costly అన్నమాట. ఇది second problem.
wavs/RFAIqyP6mZc_vocals00010255.wav,Third problem ఏంటంటే index fragmentation. మీరు ఒకసారి ఈ బొమ్మను చూసి భయపడకండి. It's just a B-tree అనమాట. మీకు just visual explanation కోసం చూపిస్తున్నాను. ఈ B-tree లోనే మన exact గా data ని store చేసుకుంటాం ఇక్కడ. దీన్ని leaf nodes అంటారు. ఈ leaf nodesలోనే exact గా మన rows అనేవి ఇక్కడే store అవుతాయనమాట.
wavs/RFAIqyP6mZc_vocals00010619.wav,ఓకేనా Facebook లోని constant గా data ని update చేస్తున్నాం delete చేస్తున్నాం data update చేస్తున్నాం delete చేస్తున్నాం ఇవన్నీ చేయడం వల్ల ఏమవుద్ది అంటే మీ page లోని gaps form అయిపోతాయి అన్నమాట simple గా చెప్పాలంటే ఇక్కడ books rack చూసారా ఇప్పుడు books rack లోని data వరుసగా పెట్టాను నేను ఇప్పుడు నేను for example ఈ data ని తీసి ఈ book ని తీశాను అనుకోండి ఇక్కడొక gap form అయిపోద్ది కదా
wavs/RFAIqyP6mZc_vocals00011063.wav,"ఇలాగ ఏమవుతుందంటే నువ్వు రోజు నుండి data ని తీసి పెట్టడం వల్ల చాలా gaps form అయిపోతాయి. దాన్నే fragmentation అంటారన్నమాట. ఈ fragmentation వల్ల problem ఏంటి అంటే, మీ దగ్గర one TB hard disk తీసుకో"
wavs/RFAIqyP6mZc_vocals00011312.wav,"దాంట్లో thirty percent, twenty percent ఖాళీలే ఉంటాయన్నమాట. ఆ ఖాళీలో data పెట్టలేవు. ఆ ఖాళీలో data పెట్టాలి అంటే మళ్ళీ data మొత్తం సర్దుకొని పెద్ద ఖాళీ చేసుకొని దాంట్లో మళ్ళీ data పెట్టుకోవాలన్నమాట. just మన ఇంట్లో, మన ఇంట్లో సామాను సర్దుకున్నట్టే."
wavs/RFAIqyP6mZc_vocals00011620.wav,"Already MySQL లోని ఈ problem solve చేయడం కోసం కొన్ని techniques ఉన్నాయన్నమాట. కాకపోతే ఆ techniques అనేవి MySQL scale కి ఎందుకో work కాలేదన్నమాట. And moreover, ఇలా ఒక fixed sixteen KB size వాడటం వల్ల ఎప్పుడూ data ఖాళీగా ఉండిపోవడం గాని data నిండిపోయి ఇంకో page లోకి వెళ్ళిపోవడం గాని"
wavs/RFAIqyP6mZc_vocals00011963.wav,ఇలాంటి problems అనేవి ఎప్పుడూ common గా జరిగాయన్నమాట. So ఈ మూడు problems వల్ల Facebook అనేది చాలా cost pay చేయాల్సి వచ్చిందన్నమాట MySQL servers maintain చేయడం కోసం
wavs/RFAIqyP6mZc_vocals00012159.wav,"Facebook ఇది అంతా చూసిందన్నమాట. ఏంట్రా మనం ఈ problem solution తయారు చేయలేమా అని చెప్పేసి, అప్పుడు Facebook దగ్గర ఉన్న developers అందర్నీ open source community search చేయడం మొదలు పెట్టారు. అయితే వాళ్ళకి RocksDB అని ఒక database దొరికిందన్నమాట"
wavs/RFAIqyP6mZc_vocals00012420.wav,ఈ RocksDB InnoDB లాగా B+ tree వాడకుండా అది LSM tree అని వేరే ఒక tree వాడుతుందన్నమాట
wavs/RFAIqyP6mZc_vocals00012555.wav,"Facebook ఇదంతా observe చేసి ఇదేదో మనకు work అయ్యేలా ఉంది అనుకుంది అనమాట. ఎందుకంటే Facebook లో database ఉంది చూడండి. ఎక్కడైతే మన పోస్ట్స్, likes, comments ఇవన్నీ store చేస్తామో, దానికి ఎక్కువ rights వస్తాయి అనమాట. Reads అన్నిటి కోసం కూడాను వాళ్ళు వేలేగా ఒక cache layer create చేశారు అనమాట."
wavs/RFAIqyP6mZc_vocals00012886.wav,సో ఈ cache layerలోనే చాలా మట్టు reads అన్నీ అయిపోతాయి. సో వాళ్ళకి ఏం కావాలి అంటే write optimized database అనేది ఒకటి కావాలి. సో Facebook ఏం చేసిందంటే
wavs/RFAIqyP6mZc_vocals00013095.wav,ఇది దాని MySQL database అనమాట. ఈ MySQL database లోని initial layers అయినా query planner query optimizer అవన్నీ అలానే ఉంచిందనమాట.
wavs/RFAIqyP6mZc_vocals00013270.wav,లోపట్నున్న InnoDB engine ని replace చేసింది. InnoDB engine ని పక్కన పెట్టి అది వేరేగా MyRocks engine అని చెప్పేసి ఒకటి create చేసిందన్నమాట. ఎక్కడి నుంచి inspire అయ్యి? RocksDB నుంచి inspire అయ్యి MyRocks engine అనేది create చేసింది.
wavs/RFAIqyP6mZc_vocals00013553.wav,ఈ MyRocks ఇంజన్ obvious గాను LSM trees ని internal గా వాడుతుందన్నమాట. ఇప్పుడు మనమేం చేద్దాం అంటే అసలు ఈ LSM trees అనేవి internal గాను writes ఎలా work అవుతాయి reads ఎలా work అవుతాయో ఒకసారి చూద్దాం.
wavs/RFAIqyP6mZc_vocals00013810.wav,"ఎల్ ఎస్ ఎన్ tree అనేది kind of tree structure లా కాదు, it's a group of data structures లాగా అనుకోండి. ఇప్పుడు దీంట్లోని ఒక write ఎలా work అవుద్దో ఒకసారి చూద్దాం."
wavs/RFAIqyP6mZc_vocals00014109.wav,ఇది మీ కొత్త server అనమాట. ఈ కొత్త server లోని ఒక ఇది server ఇది disk
wavs/RFAIqyP6mZc_vocals00014245.wav,"ఇప్పుడు దీనికి మీరు ఒక insert query ఇచ్చారన్నమాట, okay, SQLలోని. ఏమని? age ఏమో, ఆ, fifty user id one two three కి update చెయ్యు అని చెప్పేసాను, okay నా. ఇది first ఏం చేస్తుందంటే initial గా మనకి SQL layers ఉంటాయి, okay నా."
wavs/RFAIqyP6mZc_vocals00014612.wav,ఆ SQL layers through అది first go through అవుతది. Go through అవ్వగానే దాని తర్వాత మన ro-- MyRocks engine లోకి enter అవుతది. MyRocks engine లో మీరు observe చేస్తే ఇక్కడ memtable అనే ఒక data structure ఉందన్నమాట.
wavs/RFAIqyP6mZc_vocals00014881.wav,ఈ Memtable అనేది internal గా ఒక Linked List లాంటిది అనమాట. దీంట్లో data అనేది sorted గా store చేసుకోవచ్చు.
wavs/RFAIqyP6mZc_vocals00015020.wav,"మన ఈ mem table internal complete గా వెళ్ళదు గానీ, but ఇది overall గా ఏంటంటే order of login లోనే మనం data ని read చేయొచ్చు write చేయొచ్చు. Okay నా?"
wavs/RFAIqyP6mZc_vocals00015216.wav,So first user ఆ first insert query రాగానే mem tableలోనే first మనం ఈ data ని store చేసుకుంటాం.
wavs/RFAIqyP6mZc_vocals00015392.wav,"ఓకే నా, store చేసుకున్న తర్వాత obvious ga memtable అనేది ఎక్కడ ఉంది? RAM లో ఉంది. RAM లో ఉంటే data అనేది అంత durable కాదు కాబట్టి, మనం same MySQL లాగానే data ని redo log లో కూడా store చేసుకుంటాం అనమాట."
wavs/RFAIqyP6mZc_vocals00015669.wav,సో దీని వల్ల మనకి durability అనేది వచ్చేసింది. ఇప్పుడు మన user కి success response అనేది ఇచ్చేస్తాం. so నువ్వు ఇంకోసారి ఇప్పుడు user one two three కి ఏమో age అనేది forty అని update చేయమంటున్నావ్ అనుకో general గా అయితే ఏం అవ్వాలి?
wavs/RFAIqyP6mZc_vocals00015994.wav,"Fifty అనే data ని forty తో update చేయాలి. కాకపోతే mem tables అనేవి immutable అన్నమాట. immutable అంటే ఏంటి అంటే, దాంట్లోని data ని అసలు update చేసే choice లేదనమాట."
wavs/RFAIqyP6mZc_vocals00016229.wav,"Either ప్రతిసారి వాళ్ళకి update ని అడిగితే అది కొత్త row నే create చేస్తది అనమాట. So అది ఏం చేసిందంటే కొత్తగా ఇంకో row ని create చేసిందనమాట. ఇది latest row, ఇది old row అని చెప్పేసి అని అది signify చేసింది."
wavs/RFAIqyP6mZc_vocals00016499.wav,"సో, ఈ విధంగా data అనేది ఎప్పుడూ overwrite అవ్వదన్నమాట. కొత్త row ఏ create అవుతది. సో, ఇప్పుడు memtable కి ఒక fixed గా ఒక sixty four MB అనే size ఉంటాదన్నమాట. ఓకే నా? సో, ఎప్పుడైతే data అలా రావడం వల్ల ఈ sixty four MB అనేది నిండిపోతాదో, అప్పుడు ఏమవుతుందంటే memtable అనేది simple గా డిస్క్ దగ్గరికి వెళ్లి ఆ data మొత్తం sorted గా persist చేస్తాదన్నమాట."
wavs/RFAIqyP6mZc_vocals00017019.wav,దాన్నే మనం ఏమంటాం అంటే అసిస్టేబుల్ అంటాం
wavs/RFAIqyP6mZc_vocals00017139.wav,సో initially ఇప్పుడు ఏమవుతుంది mem table కి అలా writes అన్నీ రాగానే ఆ writes అన్నీ అది complete గా sorted way గా store చేసుకుంటుంది. Store చేసుకొని ఎప్పుడైతే sixty four MB అయిపోద్దో అప్పుడు అది SSTable లా create అవుతుంది.
wavs/RFAIqyP6mZc_vocals00017395.wav,"ఓకే నా! ఎప్పుడైతే ఈ mem table అనేది SSTable లో ఆ save అయిపోయిందో, మనం ఏం చేస్తామంటే, ఈ mem table అనేది ఇక్కడి నుంచి delete అయిపోతది. ఓకే నా? delete అయిపోయిన తర్వాత మళ్ళీ కొత్త writes వచ్చాయనుకో, మళ్ళీ కొత్త writes దగ్గర మనం ఏం చేస్తాం? ఇంకో mem table create చేస్తామన్నమాట. ఇంకో mem table create చేసి దాంట్లో ఆ writes అన్ని store చేసుకుంటాం."
wavs/RFAIqyP6mZc_vocals00017834.wav,ఎప్పుడైతే ఈ కొత్త mem table కూడాను sixty four MB reach అయిపోద్దో అప్పుడు దాన్ని మళ్ళీ మనం డిస్క్ లోకి ఒక SSTable లో store చేసుకుంటాం.
wavs/RFAIqyP6mZc_vocals00018018.wav,సో ఈ విధంగా నీ data అనేది first mem table లోకి వెళ్తాది. దాని తర్వాత ఆ నీ SSTable లోకి sequential గా రాస్తాం. ఇక్కడ నువ్వు observe చేస్తే data అనేది mem table నుంచి ఇప్పుడైతే డిస్క్ లోకి రాస్తున్నాము.
wavs/RFAIqyP6mZc_vocals00018320.wav,డిస్క్ లోని ఆ sixty-four MB sequential గా రాస్తున్నాం. మనకు ముందే తెలుసు. ఏంటి? Sequential writes are always faster than random writes అనమాట
wavs/RFAIqyP6mZc_vocals00018510.wav,డిస్క్ లో ఎప్పుడూ ఆ property ఉంటది. so ఇక్కడ మనం observe చేస్తే SSTable లోనే data ఉండొచ్చు SSTable లో కూడా data ఉండొచ్చు. ఎందుకు data duplication ఉండే chances ఉన్నాయన్నమాట. so ఇప్పుడు మనం ఏం చేద్దాం అంటే అసలు ఈ LSM trees లోని reads ఎలా work అవుతాయో ఒకసారి చూద్దాం.
wavs/RFAIqyP6mZc_vocals00018934.wav,సో మీరు observe చేస్తే ఇక్కడ మన server ఉంది ఇక్కడ మన disk ఉంది. ఇప్పుడు disk లోని చాలా SSTables ఉన్నాయన్నమాట
wavs/RFAIqyP6mZc_vocals00019109.wav,"ఇక్కడొక mem table ఉంది. ఇప్పుడు first నువ్వు user id one, two, three యొక్క age ఇవ్వండి అని అడిగావు. ఓకే నా? Age ఇవ్వండి అని అడగ్గానే first అది ఏం చేస్తుంది అంటే mem table దగ్గరికి వెళ్లి check చేస్తుంది. Mem table లోనే అసలు user id key ఉందా లేదా అని చెక్ చేస్తుంది."
wavs/RFAIqyP6mZc_vocals00019415.wav,"ఇప్పుడు mem table లోని multiple rows కూడా ఉండొచ్చు same user id key. ఓకే నా? ఇప్పుడు ఒకవేళ mem table లోని అసలు user id key లేదు అనుకున్నది అనుకో, అది ఏం చేస్తుంది అంటే latest గా ఉన్న SSTable దగ్గరికి వెళ్తుంది"
wavs/RFAIqyP6mZc_vocals00019661.wav,ఇప్పుడు latest SSTable లోని user ID one two three ఉందో లేదో చెక్ చేస్తాది. దానికోసం bloom filters అని వేరే concept ఉంది. అది ఇప్పుడు నేను explain చేయను. But first ఈ SSTable చెక్ చేస్తాది
wavs/RFAIqyP6mZc_vocals00019856.wav,దీంట్లో లేదనుకోండి దాని పైన దానికి వెళ్తాది. దాంట్లో కూడా లేదనుకోండి దీని పైనకి వెళ్తాది. సో అలాగా ఒక read చేయడానికి అది multiple levels SSTables ని చూడాల్సి వస్తది అనమాట.
wavs/RFAIqyP6mZc_vocals00020065.wav,"సో LSM tree అనుకుంది ఇది కొంచెం complicated గా ఉంది ఎందుకంటే reads మరీ కష్టమైపోతున్నాయి. సో, మనం ఏం చేద్దాం అంటే ఈ SSTables లో ఎక్కడైతే duplicate data ఉందో ఆ SSTablesని merge చేద్దాం. అంటే compact చేద్దాం అని చెప్పేసని compaction concept తెచ్చిందన్నమాట."
wavs/RFAIqyP6mZc_vocals00020430.wav,ఈ compassion లో ఏమవుద్ది అంటే ESS టేబులు ESS టేబులు కలిసి
wavs/RFAIqyP6mZc_vocals00020542.wav,ఒక కొత్త SSTable create అవుతుంది అన్నమాట డిస్క్ లోని. ఈ కొత్త SSTable లోని data అనేది sorted గా ఉంటది at the same time duplicates ఉండవు అన్నమాట.
wavs/RFAIqyP6mZc_vocals00020766.wav,"ఓకే duplicate ఉండకపోవడం వల్ల దీని వల్ల ఏమవుద్ది అంటే మనం reads చేస్తున్నప్పుడు దాని performance అనేది fast గా ఉంటాది అనమాట. ఇప్పుడు నీ disk లో చాలా excess tables ఉన్నాయి, అసలు ఏ రెండు tables మనం compact చేస్తాం అనేది కూడా ఒక algorithm ఉందనమాట."
wavs/RFAIqyP6mZc_vocals00021063.wav,"Facebook ఏం చేసిందంటే, దానికోసం leveled compaction అని ఒక concept తెచ్చిందన్నమాట"
wavs/RFAIqyP6mZc_vocals00021166.wav,"ఈ level compassion ఏమవుదంటే, మీ డిస్క్ లోని చాలా SSTables ఉంటాయి కదా, వాటిని levelsలా segregate చేసుకుందన్నమాట. first L0 ఉంది. ఈ L0 level లోని two fifty six MB వరకు data పడతాది అని చెప్పిందన్నమాట."
wavs/RFAIqyP6mZc_vocals00021464.wav,"Next L1 అంది L1 లో ఏమో two GB వరకు data పడతాది అన్నది. Next L2 అన్నది L2 లో ఏమో twenty GB దాకా data పడతాది అన్నది అనమాట. ఇప్పుడు ఏమవుద్ది అంటే, మీ ఇప్పుడు RAM లోని mem table ఉంటది కదా, మీ mem table నిండిపోగానే అది first L0 లో ఉన్న SSTable లోకి convert అవుద్ది అనమాట."
wavs/RFAIqyP6mZc_vocals00021839.wav,"సో, అలాగని మీ mem table ఎప్పుడు నిండిపోయినా, ఆ data మొత్తం first L0 లోకి వస్తది. ఈ L0 re-SSTable అనేది basic గా duplicates ఉంటాయి but sorted గా ఉంటది."
wavs/RFAIqyP6mZc_vocals00022079.wav,ఓకే ప్రతిదీ ఇక్కడ data sorted గా ఉంటుందన్నమాట. కాకపోతే ఇక్కడ S table లోనే duplicates ఉంటాయి. ఎప్పుడైతే L0 కొంచెం నిండిపోతుంది అనిపిస్తుందో అప్పుడు ఏం చేస్తుందంటే ఈ SSTable అనేది
wavs/RFAIqyP6mZc_vocals00022294.wav,ఈ L1 లో ఉన్న SSTable తో merge అవ్వుద్ది అనమాట compact అయ్యి complete గా ఒక కొత్త SSTable నే create చేస్తది అనమాట
wavs/RFAIqyP6mZc_vocals00022485.wav,ఓకే. ఈ రెండు delete అయిపోయి ఒక కొత్త SSTable ని create చేస్తుందన్నమాట
wavs/RFAIqyP6mZc_vocals00022605.wav,ఈ SSTable లోని data అనేది duplicates ఇంక ఉండవ్. కాకపోతే sorted గానే ఉంటది. So L1 లో ఉన్న ప్రతి SSTable key ను data అనేది ఎప్పుడూ sorted గా ఉంటది with no duplicates అనమాట.
wavs/RFAIqyP6mZc_vocals00022894.wav,అలానే L1 అనేది ఎప్పుడు నిండిపోయిందో అప్పుడు data అనేది L1 నుంచి L2 లోని hash table తో compact అయ్యి అక్కడొక కొత్త hash table create అవుద్ధన్నమాట
wavs/RFAIqyP6mZc_vocals00023099.wav,సో ఈ విధంగా data అనేది L0 నుంచి L1 కి L1 నుంచి L2 కి ఇలా migrate అవుతూ ఉంటాదన్నమాట
wavs/RFAIqyP6mZc_vocals00023229.wav,"ఇప్పుడు ఒక level నుంచి ఇంకో level కి assessable ఎప్పుడు move అవ్వాలా అని చెప్పేసి అని Facebook అనేది different, different trigger points define చేసిందన్నమాట"
wavs/RFAIqyP6mZc_vocals00023410.wav,"సో, ఈ విధంగా leveled compaction పెట్టుకోవడం వల్ల reads ని అది optimize చేసింది అని చెప్పేసి Facebook claim చేస్తుందన్నమాట."
wavs/RFAIqyP6mZc_vocals00023563.wav,"సో, ఈ విధంగా LSM trees లోని writes reads అవుతాయి. ఇప్పుడు మీకు అనిపించొచ్చు, ఓకే LSM tree ఏదో అర్థమైంది reads అన్నా writes అన్నా బాగుంది"
wavs/RFAIqyP6mZc_vocals00023758.wav,"కాకపోతే అసలు ఈ B+ tree లో ఉన్న problems, ఈ LSM trees ఎలా solve చేసుకోవాలో మనం ఇంతవరకు discuss చేసుకోలేదు. అది ఒకసారి discuss చేసుకుందాం."
wavs/RFAIqyP6mZc_vocals00024007.wav,"For example మనం చేసుకున్న discussion ఏంటి? First అనేది write amplification. Write amplification అనేది మన InnoDB B+ tree లో చాలా ఎక్కువుంది అని చెప్పేసి అన్నాం. అంటే మనం ఒక 2KB data రాసినా, అది డిస్క్ లోకి వెళ్ళి ఒక redo log అవుతుంది, ఒక 16KB data page లో update అవుతుంది at the same time ఏమో double write buffer కూడా write అవుతుంది. ఈ విధంగా write amplification అనేది అవుతుంది."
wavs/RFAIqyP6mZc_vocals00024507.wav,ఇప్పుడు అసలు ఈ LSM ట్రీస్ లోని write amplification ఎలా ఉంటదో ఒకసారి చూద్దాం. first ఏమవుతది? నీ దగ్గర ఒక mem table ఉంటది
wavs/RFAIqyP6mZc_vocals00024699.wav,"ఆ mem table లోని నువ్వొక row అనేది రాసావ్. ఈ row అనేది let's say ఒక two KB ఉంది. Okay నా? ఇప్పుడు నువ్వేం చేస్తావు? ఆ row ని simple గా ఒక SSTableలోకి final గా నువ్వు store చేస్తావ్. so, నీ row అనేది final గా first time disk లోకి enter అయింది. Okay? అది SSTableలో store అయింది. ఇప్పుడు"
wavs/RFAIqyP6mZc_vocals00025097.wav,ఇప్పుడు నీ SSTable అనేది L1 లోని SSTable తో ఎప్పుడో ఒకప్పుడు compact అవుతుంది అనమాట. Compact అయినప్పుడు మనం ఏం చేస్తాం కొత్త SSTable create చేసుకొని అక్కడ కూడా నీ row ని మళ్ళీ write చేస్తాం.
wavs/RFAIqyP6mZc_vocals00025375.wav,"సీ నీ row ఇంకోసారి write చేసాం. మళ్ళీ ఏమవుతది? ఈ SSTable అనేది ఇంకోసారి దాని పైన SSTable తో మళ్ళీ compact అయ్యి, మళ్ళీ ఇంకో కొత్త SSTable create చేసుకుని దాంట్లో కూడా row రాస్తావు అన్నమాట"
wavs/RFAIqyP6mZc_vocals00025668.wav,సో ఇక్కడ నువ్వు overall గా observe చేస్తే అసలు నీ row finesse table ఎన్ని సార్లు compact అవుతుంది అనే దాన్ని బట్టి అన్ని సార్లు నువ్వు same row ని మళ్ళీ రాస్తున్నావ్ అనమాట. సో Facebook ఏం figure out చేసిందంటే ఈ leveled compaction వల్ల ఈ compaction అనేది తక్కువ అవ్వాలి at the same time controlled గా అవ్వాలి అని చెప్పేసి figure out చేసిందనమాట.
wavs/RFAIqyP6mZc_vocals00026099.wav,"సో, దీని వల్ల ఏమంటే ఇప్పుడు నువ్వు InnoDB లో ఒక data రాయగానే thirteen MB అది రాస్తుంది అనుకోండి ఆ data వల్లనూ అదే నువ్వు ఈ LSM treeలోని కేవలం four MB data మాత్రమే రాస్తావ్ అన్నమాట"
wavs/RFAIqyP6mZc_vocals00026392.wav,సో దీని వల్ల నీ write amplification అనేది almost ఒక four x times తగ్గిపోయింది LSM trees లోని. Second problem ఏంటి? Hardware wear and tear
wavs/RFAIqyP6mZc_vocals00026644.wav,"ఓకే అండి. ఇప్పుడు write amplification తక్కువ ఉండడం వల్ల నువ్వు data ని ఎక్కువ సార్లు రాయవు అనమాట. ఎక్కువ సార్లు రాయకపోవడం వల్ల నీ hardware cycles అనేవి ఎక్కువ consume అవ్వవు. సో, నీ disk అనేది తక్కువ hardware cycles ఉన్నా కూడానూ ఆ data మొత్తాన్ని manage చేసేదన్నమాట"
wavs/RFAIqyP6mZc_vocals00027008.wav,"సో, దాని వల్ల అది benefit. Third problem ఏంటంటే fragmentation అన్నమాట. మీరు observe చేస్తే MySQL లోని మనం sixteen KB slot అని ఒక slot ఇచ్చామన్నమాట. ఇప్పుడు ఈ slot లో కొన్ని కొన్ని సార్లు data తక్కువ పట్టొచ్చు, లేకపోతే data overflow అయ్యి రెండు pages తీసుకోవచ్చు."
wavs/RFAIqyP6mZc_vocals00027340.wav,సో దీని వల్ల ఎప్పుడూ data అనేది gaps ఉండవనేది ఎప్పుడూ MySQL జరుగుతుందన్నమాట
wavs/RFAIqyP6mZc_vocals00027438.wav,అది ఇప్పుడు మనం LSM trees చూస్తే దీంట్లో ఎలా అవుతుందంటే mem table నుంచి data రాగానే దాన్ని simple గా ఒక sixty four MB SSTable లాగా మనం create చేసేస్తున్నామన్నమాట sequential గాను
wavs/RFAIqyP6mZc_vocals00027658.wav,డేటా ఎక్కడ fixed slot లో పెట్టట్లేదు. at the same time రెండు SSTables merge అవుతున్నప్పుడు మళ్ళీ ఇంకో కొత్త SSTable మనం అలా create చేసి కెళ్ళిపోతున్నాం అనమాట.
wavs/RFAIqyP6mZc_vocals00027859.wav,అక్కడ కూడా data ఎక్కడ waste అవ్వట్లేదు వరుసగా create చేసుకుంటూ వెళ్ళిపోతున్నాం
wavs/RFAIqyP6mZc_vocals00027941.wav,సో ఇలాగా ఎక్కడ fixed slot లేకపోవడం వల్ల మన data ని sequential గా రాసి కెళ్ళిపోవడం వల్ల ఇక్కడ gaps అనేవి తక్కువ ఉంటున్నాయన్నమాట
wavs/RFAIqyP6mZc_vocals00028129.wav,"అది ఎంత difference అంటే, నువ్వు InnoDB లోనే ఒక data store చేద్దాం అనుకుంటే, అది one TB పడుతుంది అనుకో అక్కడ"
wavs/RFAIqyP6mZc_vocals00028269.wav,అదే ఇప్పుడు SS Table దగ్గరికి వచ్చేసరికి అది కేవలం four hundred GB లోనే store చేసుకోవచ్చన్నమాట
wavs/RFAIqyP6mZc_vocals00028382.wav,సో ఈ విధంగా LSM trees వాడటం వల్ల Facebook అనేది తన cost అనేవి ముందు ఒక four hundred crores ఉంటే ఇప్పుడు almost ఒక hundred crores తగ్గించిందన్నమాట. ఇది ఒక rough numbers మాత్రమే
wavs/RFAIqyP6mZc_vocals00028607.wav,Moreover ఈ video లోని ఆ paper నేను describe చేసి మీకు simple గా ఎలా explain చేయాలో మాత్రమే try చేశాను అనమాట. ఇంకా చాలా internal details ఉన్నాయి which are didn't go
wavs/RFAIqyP6mZc_vocals00028782.wav,సో మీకు interest ఉంటే ఆ paper నేను description లో పెడతాను. ఖచ్చితంగా మీరు go through అవ్వండమ్మా. And moreover మీ LSM trees అనేవి
wavs/RFAIqyP6mZc_vocals00028920.wav,ఎక్కడైతే writes heavy గా ఉంటాయో అలాంటి ప్రతి database లో ఇది వాడుతున్నారన్నమాట. Even మీరు observe చేస్తే Cassandra లో కూడా LS trees వాడుతున్నారు
wavs/RFAIqyP6mZc_vocals00029072.wav,Interesting కదా? Thanks for watching. Keep learning
wavs/kb2B9_A3TxE_vocals00000212.wav,"మీకు recent గా మా company లో జరిగింది చెప్పలే కదా! మా company లో ఏమైందంటే మాదొక micro service system ఆ, ఇప్పుడు ఈ micro service system లో ఏమైందంటే sudden గా ఒక micro service down అయిపోయిందన్నమాట"
wavs/kb2B9_A3TxE_vocals00000414.wav,మా friend ఏం చేశాడు down అయింది కదా అని చెప్పేసి దాన్ని restart చేశాడు restart చేస్తే work అవ్వాలి కదా కానీ అది ఏమైంది మళ్ళీ down అయిపోయిందన్నమాట
wavs/kb2B9_A3TxE_vocals00000574.wav,"ఎందుకని లోపలికి వెళ్లి చూస్తే ఈ micro service ఉంది కదా, దీనికి చాలా మంది clients కలుస్తున్నారు. ఇప్పుడు ఈ clients అందరూ ఏం చేశారు?"
wavs/kb2B9_A3TxE_vocals00000755.wav,దీని నుంచి response రావట్లేదు కదా అని చెప్పేసి అని constantly retrace చేస్తున్నారు. ఈ retrace చేయడం వల్ల ఈ service restart చేసినా కూడా down అయిపోతున్నాడు constantly గా అని
wavs/kb2B9_A3TxE_vocals00000946.wav,"మా లీడ్ ఇదంతా చూశాడు. చూసి ఏంటి మీరు అసలు రిటైర్ సరిగ్గా maintain చేయట్లేదు, మీది అసలు retry code మీది బాలేదు అని చెప్పేసని దాని మీద పెద్ద master class వేస్తున్నాడు. ఈ టైంలో నువ్వు సినిమాకి రమ్మంటున్నావ్"
wavs/kb2B9_A3TxE_vocals00001291.wav,"బా చెప్తాను అయితే. Let's say ఇది ఒక order system, ఇది ఒక inventory system. Okay నా?"
wavs/kb2B9_A3TxE_vocals00001424.wav,"ఇదొక order service, ఇదొక inventory service"
wavs/kb2B9_A3TxE_vocals00001501.wav,ఇప్పుడు order service ఏం చేస్తుందంటే inventory service కి ఒక API call చేస్తుంది
wavs/kb2B9_A3TxE_vocals00001633.wav,ఏమని? అరే నేను order ఇలాగ book చేశానురా దానికి inventory reserve చేయరా అని చెప్పేసి API call చేస్తుంది
wavs/kb2B9_A3TxE_vocals00001776.wav,"ఇప్పుడు ఈ API అనేది దానికి errors వస్తున్నాయన్నమాట. ఓకే నా. So first మనం figure out చేయాల్సింది ఏంటి అంటే, అసలు ఎప్పుడు retrace చేయాలి అని first మనం figure out చేయాలన్నమాట"
wavs/kb2B9_A3TxE_vocals00002015.wav,ఎప్పుడు retrace చేయాలి? For example API కి ఒక four hundred error వచ్చింది. Four hundred error అంటే ఏంటి? నువ్వు wrong arguments పంపించావు. Next ఇంకేం error వస్తది? Five hundred error వస్తది. ఇప్పుడు five hundred error అంటే ఏంటి? అదొక internal server error
wavs/kb2B9_A3TxE_vocals00002301.wav,"లేకపోతే five not two గాకపోతే, లేకపోతే different different time out errors గాని, ఇలా different different errors వస్తాయన్నమాట"
wavs/kb2B9_A3TxE_vocals00002446.wav,సో first మనం తెలుసుకోవాల్సింది ఏంటంటే అసలు ఏ error code కి మనం retry చెయ్యాలి అని చెప్పేసి అండి. ఇప్పుడు four hundred error వచ్చింది అనుకో four hundred error retry చేసేస్తాం ఏంటి? చెయ్యం. ఎందుకు? చేసినా కూడా same error ఏ వస్తుంది కాబట్టి
wavs/kb2B9_A3TxE_vocals00002711.wav,అదే time out error అనుకో దానికి retry చేస్తే work అవ్వచ్చు. So first మనం figure out చేయాల్సింది ఏంటంటే ఎలాంటి errors వచ్చినప్పుడు retry చేయాలి అని చెప్పేసి.
wavs/kb2B9_A3TxE_vocals00002878.wav,ఇప్పుడు అది fix అయిన తర్వాత ఇప్పుడు retry కి different different mechanisms ఉంటాయి అంట. First thing ఏంటి అంటే fixed retry. అంటే ఏంటి?
wavs/kb2B9_A3TxE_vocals00003146.wav,"ఇప్పుడు fixed retry ఏమౌతుందంటే, నీ order system ఉంది, నీ inventory system ఉంది. Okay నా? ఇప్పుడు ఎప్పుడైతే నువ్వు API call చేయగానే నీకు ఒక error వచ్చింది. Okay నా? Error రాగానే నువ్వు retry చేద్దాం fix అయ్యావు."
wavs/kb2B9_A3TxE_vocals00003389.wav,ఇప్పుడు order system దగ్గర maximum ఒక ten retrace చేయు అని చెప్పేసి అని అంటాం అన్నమాట fixed గా పెట్టేస్తాం. ఇదేం చేస్తాది error రాగానే ఒక retry చేస్తాది
wavs/kb2B9_A3TxE_vocals00003621.wav,ఇప్పుడు retry కూడా error వచ్చిందనుకో మళ్ళీ ఇంకో try చేస్తదనమాట. దానికి కూడా మళ్ళీ error వచ్చిందనుకో మళ్ళీ try చేస్తది. అలాగ ఒక ten times అలా చేస్తూ ఉంటదనమాట constant గాను
wavs/kb2B9_A3TxE_vocals00003867.wav,"ఇప్పుడు నీకు ఇదేమనిపిస్తుంది? బానే ఉంది కదా అనిపిస్తుంది కదా! కానీ, ఇక్కడ నువ్వు observe చేస్తే ఇప్పుడు నీ inventory system కి చాలా మంది clients call చేస్తున్నారనుకో, ఇప్పుడు ఈ చాలా మంది clients constant గా blind గా retrace చేసేస్తున్నారనుకో"
wavs/kb2B9_A3TxE_vocals00004178.wav,"అప్పుడు చాలా blind అయిపోద్ది అనమాట. మీద pressure చాలా ఎక్కువ పెరిగిపోతాది. ఓకే నా? సో, అందుకే ఈ blind mechanism అనేది maybe చిన్న scale లో work అయిపోతాది. Even మా scale లో కూడా చాలా సార్లు work అయిపోయింది అనమాట."
wavs/kb2B9_A3TxE_vocals00004424.wav,కాకపోతే కొంచెం ఎక్కువ micro services పెద్ద scale కి వెళ్ళేటప్పటికీ ఈ blind retrace అనేది అంత ఎక్కువగా work కాదన్నమాట. అందుకే మనం blind గా retry చేయకుండా దీని కోసం second ఇంకా option ఉంటుందన్నమాట. అదేంటంటే exponential retry అనమాట. ఈ exponential retry ఏమవుద్దంటే ఒకసారి చెప్తాను.
wavs/kb2B9_A3TxE_vocals00004832.wav,"ఇప్పుడు నీ order ఉంది, నీ inventory ఉంది, నువ్వు API call చేసావ్, నీకేమో error వచ్చింది. ఇంతవరకు story బానే ఉంది కదా. ఇప్పుడు ఏం చేస్తామంటే first అది ఒక retry చేస్తానమాట."
wavs/kb2B9_A3TxE_vocals00005075.wav,ఓకే నా retry చేసిన తర్వాత ఆ retry కి error వచ్చింది అనుకో అది ఏం చేస్తుందంటే వెంటనే ఇంకో retry చేయకుండా ఒక hundred milliseconds wait చేస్తుందన్నమాట
wavs/kb2B9_A3TxE_vocals00005273.wav,"Wait చేసిన తర్వాత ఇంకో retry చేస్తాదన్నమాట. ఇప్పుడు ఆ retry కూడా error వచ్చింది అనుకో, అదేం చేస్తదంటే మళ్ళీ hundred milliseconds కాకుండా let's say ఒక three hundred milliseconds wait చేస్తాది"
wavs/kb2B9_A3TxE_vocals00005496.wav,"ఓకే నా, అప్పుడు ఇంకో retry చేస్తది. దానికి కూడా error వచ్చింది అనుకో, ఈసారి ఏం చేస్తుందంటే six hundred milliseconds wait చేస్తుందన్నమాట"
wavs/kb2B9_A3TxE_vocals00005656.wav,"సో ఇక్కడ నువ్వు observe చేస్తే constant గా ఏమవుతుంది అంటే, మనం ఒకటే time period లో retrace చేయకుండా ఒక exponential way లోని మనం time పెంచుకుంటూ పెంచుకుంటూ retrace చేస్తున్నామన్నమాట"
wavs/kb2B9_A3TxE_vocals00005880.wav,దీని వల్ల మన inventory service మీద మరీ ఎక్కువ pressure వెంట వెంటనే పడదు అనమాట. అది దాని whole goal. ఇప్పుడు ఇదంతా బానే ఉంది వినడానికి
wavs/kb2B9_A3TxE_vocals00006035.wav,కాకపోతే దీంట్లో కూడా problem ఉందన్నమాట. అదేంటంటే ఇప్పుడు నీ inventory system ఉంది. ఇప్పుడు నీ inventory system కి చాలా మంది clients exponential గా retry చేస్తున్నారు
wavs/kb2B9_A3TxE_vocals00006236.wav,Ideal గా బానే work అవ్వాలి. కాకపోతే even exponential లో కూడానూ ఆ clients అందరూ ఒకటే time కి పిలుస్తున్నారన్నమాట. అంటే ఎలాగా? first minute hundred milliseconds కి అందరూ పిలుస్తున్నారు
wavs/kb2B9_A3TxE_vocals00006482.wav,"Next అందరూ wait చేస్తున్నారు, మళ్ళీ three hundred milliseconds కి అందరూ పిలుస్తున్నారు. మళ్ళీ అందరూ wait చేస్తున్నారు, మళ్ళీ six hundred milliseconds కి అందరూ పిలుస్తున్నారు"
wavs/kb2B9_A3TxE_vocals00006649.wav,సో ఈవెన్ exponential retrace లో కూడానూ అందరూ ఒకేసారి పెట్టడం- పిలవడం వల్ల నీ inventory system మీద మళ్ళీ pressure పెరిగిపోతుందన్నమాట
wavs/kb2B9_A3TxE_vocals00006826.wav,"అందుకే మనం దీని కోసం ఏం చేస్తామంటే జెట్టరింగ్ అనే కాన్సెప్ట్ వాడతాం. ఈ జెట్టరింగ్ లో ఏం చేస్తామంటే ప్రతి సర్వీస్ లో కూడాను, ప్రతి క్లయింట్ లో కూడాను random గా ఏదో ఒక number add చేస్తాం అనమాట."
wavs/kb2B9_A3TxE_vocals00007079.wav,"Random గా number add చేయడం వల్ల ఏమవుతుందంటే, అందరూ ఒకేసారి పిలవకుండా వాళ్ళ load అనేది distribute అవుద్ధు అన్నమాట. ఒక్కొక్కళ్ళు ఒక్కో time లో పిలవాల్సి వస్తుంది అనమాట."
wavs/kb2B9_A3TxE_vocals00007264.wav,సో ఈ విధంగా మీ inventory system ని exponential chatter వాడడం వల్ల దాని మీద మరీ heavy load పెళ్ళకుండా మనం కొంచం కాపాడొచ్చనమాట.
wavs/kb2B9_A3TxE_vocals00007432.wav,ఇప్పుడు ఈ exponential jitter వీటి వల్ల కూడా మనకు కొంచెం problem ఉందన్నమాట. ఆ problem ఏంటి అంటే ఒకసారి చెప్తాను. ఇప్పుడు let's say నీ దగ్గర ఒక order system ఉంది
wavs/kb2B9_A3TxE_vocals00007646.wav,ఒక inventory system ఉంది. ఇప్పుడు మనమేమంటున్నాం order అనేది inventory కి ఒక API call చేసింది. ఆ API call అనేది fail అయ్యింది. Okay నా? ఇప్పుడు order ఏం చేస్తాది? simple గా ఒక retry చేసుకుంటాది
wavs/kb2B9_A3TxE_vocals00007879.wav,ఓకే నా! ఇప్పుడు retry చేసినప్పుడు observe చేస్తే order system లోని దీనికి ఒక thread ఉంటాదన్నమాట. ఆ thread అనేది అలా ఉండిపోతాది.
wavs/kb2B9_A3TxE_vocals00008046.wav,మళ్ళీ నువ్వేమంటున్నావు? ఈ retry కూడా error వస్తే అది కొంత సేపు అది ఇంకో retry చేస్తదంటున్నావ్
wavs/kb2B9_A3TxE_vocals00008196.wav,"ఆ time లో ఈ thread ఇంకా అలా ఉంటదన్నమాట. So చాలా API calls అలా fail అయిపోతే కొద్ది, మీ system లోని order system లోని threads అన్నీ stuck అయిపోతూ ఉండిపోతాయన్నమాట"
wavs/kb2B9_A3TxE_vocals00008434.wav,ఈ stuck up అయితే ఉండిపోవడం వల్ల final గా నీ order system ఏ down అయిపోద్ది అన్నమాట. అదేంటిది? inventory system ని కాపాడటం కోసం నువ్వు order system ని down చేసుకుంటున్నావ్ అన్నమాట. circuit breaker అనేది ఈ problem ని చాలా intelligent గా tackle చేస్తది అన్నమాట. అది ఎలా చేస్తది అంటే
wavs/kb2B9_A3TxE_vocals00008850.wav,ఇప్పుడు నీ order system ఉంది inventory system ఉంది. నీ order అనేది inventory కి ఒక API call చేస్తుంది. ఇప్పుడు మనకి ఏమైంది? ఈ API call అనేది fail అయింది
wavs/kb2B9_A3TxE_vocals00009060.wav,దాని తర్వాత ఇంకో API call చేసింది. అది కూడా fail అయింది
wavs/kb2B9_A3TxE_vocals00009161.wav,ఇంకో API call చేసింది అది కూడా fail అయింది. ఇప్పుడు order system అనుకుంది ఎందుకురా మనం చేసిన ప్రతి API call fail అయిపోతుంది?
wavs/kb2B9_A3TxE_vocals00009335.wav,మనం ఏం చేద్దాం అంటే అసలు inventory కి పిలవడం ఆపేద్దాం. ఎందుకు పిలాలి? అది store చేసుకుంటది అన్నమాట. last sixty seconds లోని almost ఒక two hundred requests అనేవి
wavs/kb2B9_A3TxE_vocals00009574.wav,fail అయిపోతున్నాయి. ఇన్ని fail అయిపోతున్నాయి కాబట్టి ఇది ఏం చేస్తుందంటే అసలు inventory system కి పిలవను అని చెప్పేసని అది circuit open చేస్తదన్నమాట. Okay?
wavs/kb2B9_A3TxE_vocals00009766.wav,దీన్నే Circuit Breaker concept లోని Circuit Open అంటాం మాట
wavs/kb2B9_A3TxE_vocals00009876.wav,circuit open చేస్తే ఏమవుద్ది అంటే అసలు ఏ calls ఇంక inventory కి వెళ్ళవు. ఎవరైనా order system కి వచ్చి inventory reserve చెయ్ అంటే order ఏం చేస్తుందంటే
wavs/kb2B9_A3TxE_vocals00010050.wav,నేను inventory ని fill లేను అని చెప్పేసని వెంటనే వాళ్ళకి error ఇచ్చేస్తది అనమాట. దీని వల్ల benefit ఏంటి? మీ order లో threads అనేవి stuck అయిపోతూ ఉండవు. మీకు వెంట వెంటనే errors అయిపోతాయి అనమాట.
wavs/kb2B9_A3TxE_vocals00010268.wav,ఇది first benefit. ఇప్పుడు ఈ circuit ఏం చేస్తుందంటే చూస్తది
wavs/kb2B9_A3TxE_vocals00010368.wav,"చాలా సేపు మనం అసలు inventory పిలవకుండా ఉన్నాం కదా, maybe inventory బాగుపడిందేమో అని చెప్పేసని మెల్లీగా circuit ని close చేయడానికి try చేస్తున్నామాట"
wavs/kb2B9_A3TxE_vocals00010544.wav,"Circuit ని close చేసి ఒక చిన్న API call try చేస్తదన్నమాట. చిన్న API call success అయ్యిందనుకోండి, complete గా circuit close చేసేస్తది. circuit close చేసి regular API calls flow అవుతుంటదన్నమాట."
wavs/kb2B9_A3TxE_vocals00010794.wav,"ఒకవేళ ఆ API calls fail అయిపోయాయి అనుకోండి మళ్ళీ circuit open అయిపోద్ది అన్నమాట. So whole point ఏంటి అంటే, దీని వల్ల ఏంటి అంటే, మీ order system అనేది inventory down అయినా కూడానూ మీ order system అనేది safe అవ్వగలదు అన్నమాట."
wavs/kb2B9_A3TxE_vocals00011095.wav,"సో ఈ విధంగా circuit breaker వాడటం వల్ల నీ inventory system down అయినా కూడాను, నీ order system ని కొంత save చేసుకోవచ్చు"
wavs/kb2B9_A3TxE_vocals00011251.wav,"ఓకే నా. ఇప్పుడు retry mechanismలో fourth strategy ఏంటి అంటే, నీ order ఉంది, నీ order inventoryకి పిలుస్తుంది. ఇప్పుడు order inventoryకి పిలిచే timeలో ఎదో error వచ్చింది అనుకోండి, మనం simpleగా ఏం చేస్తామంటే..."
wavs/kb2B9_A3TxE_vocals00011600.wav,ఇప్పుడు order inventory పిలుస్తుంటే API fail అయింది. అప్పుడు order ఏం చేస్తుందంటే API fail అయింది కదా ఓకేలే అని చెప్పేసని ఒక message కుని పెట్టుకుంటుంది పైన
wavs/kb2B9_A3TxE_vocals00011846.wav,"ఈ message queue కి చెప్తది, అరే message queue ఈ, ఈ request ను దాచుకొని ఎప్పుడైతే inventory work అవుతదో అప్పుడు దానికి ఇచ్చేయి అని చెప్తేనే అది వెళ్లిపోద్ది అన్నమాట"
wavs/kb2B9_A3TxE_vocals00012074.wav,"ఓకే, ఇక్కడ observe చేస్తే ఇక్కడ కూడా ఏంటి అంటే అసలు మీ threads అనేవి వెంటనే block అవ్వట్లేదు"
wavs/kb2B9_A3TxE_vocals00012191.wav,ఎందుకు? request వస్తుంది check చేస్తుంది inventory fail అయిపోయిందని fail అయిపోతుందని చెప్పేసి వెంటనే message queue లో push చేస్తాం push చేసి ఆ re-- response అనేది వెళ్లిపోతుందన్నమాట
wavs/kb2B9_A3TxE_vocals00012402.wav,సో ఈ విధంగా ఏంటి అంటే ఎప్పుడైతే ఈ message queue అనేది inventory మళ్ళీ open అవుతదో అప్పుడు ఈ request అనేది inventory కి వస్తది అనమాట
wavs/kb2B9_A3TxE_vocals00012570.wav,"సో దీని వల్ల ఇక్కడ కూడా నువ్వు order ని మళ్ళీ save చేసుకుంటున్నావ్ అనమాట. సో ఇక్కడ కూడా నువ్వు observe చేస్తే, నీ order system ని మళ్ళీ నువ్వు inventory down అయినా కూడానూ ఇలా third party కి నీ request ఇచ్చేసి నువ్వు save చేసుకుంటున్నావ్ అనమాట."
wavs/kb2B9_A3TxE_vocals00012826.wav,సో ఇలా message queue వాడడం అనేది ఒక strategy. ఆహ్ generallyగా చాలా సార్లు మా companyలో ఈ message queue strategyని చాలా ఎక్కువ వాడేవారు
wavs/kb2B9_A3TxE_vocals00012971.wav,ఇంకో final strategy ఏంటి అంటే budget strategy అనమాట. ఇది చాలా interesting ఉంటది. Google వీళ్ళందరూ చాలా మంది ఇలాంటి concepts వాడేవారు అంట. మేము ఎప్పుడు వాడలేదు గానీ concept మాత్రం చదువుతున్నప్పుడు చాలా excite అయ్యాను అనమాట. అది ఎలా work అవుద్ది అంటే రా చెప్తాను.
wavs/kb2B9_A3TxE_vocals00013345.wav,ఇప్పుడు order system ఉంది inventory system ఉంది ఇప్పుడు order అనేది inventory కి ఆ request చేస్తే fail అయిపోతుంది కదా ఇప్పుడు ఏమవుద్ది అంటే ఇది మళ్ళీ ఇంకో try చేస్తాదన్నమాట okay నా మళ్ళీ ఇంకో try చేస్తాదన్నమాట ఇలా ఎన్ని సార్లు try చేసుకుంటాది అప్పుడు వాళ్ళు ఏం చేశారంటే budgeting అనే concept ఇచ్చారన్నమాట
wavs/kb2B9_A3TxE_vocals00013795.wav,బడ్జెటింగ్ లో ఏమవుద్ది అంటే అసలు order system కి maximum నేను ఒక two hundred retrace ఏ ఇస్తాను అని అంటాది అనమాట
wavs/kb2B9_A3TxE_vocals00014031.wav,అర్థమవుతుందా ఇప్పుడు order system అనేది inventoryకి let's say overall గా overall గా ఒక ten thousand requests చేయగలదు అనుకో
wavs/kb2B9_A3TxE_vocals00014202.wav,"Regular request, regular request ten thousand చేయగలిగితే retrace మాత్రం కేవలం two hundred మాత్రమే చేయగలరు అని చెప్తున్నాడన్నమాట"
wavs/kb2B9_A3TxE_vocals00014378.wav,"సో two hundred budget అయిపోగానే ఏమవుద్ది అంటే, ఇది ఇంకా retry చేయలేదు. direct గా error throw చేస్తాది"
wavs/kb2B9_A3TxE_vocals00014512.wav,"సో ఇదొక strategy అన్నమాట. సో Google గాని చాలా పెద్ద, పెద్ద companies ఈ budgeting concept వాడి"
wavs/kb2B9_A3TxE_vocals00014631.wav,"వాళ్ళ systems ని save చేసుకుంటారన్నమాట. So ఈ విధంగా మన order system అనేది different different strategies వాడతదన్నమాట, దాన్ని save చేసుకోవడం కోసం. Interesting ఉంది కదా?"
wavs/kb2B9_A3TxE_vocals00014905.wav,ఏయ్ ఇంకా matter అవలేదు. ఇంతవరకు నేను ఏం చెప్పాను? order system ఏమి చేయగలదు మాత్రమే చెప్పాను
wavs/kb2B9_A3TxE_vocals00015044.wav,ఇటువైపు inventory system కూడా కొన్ని చేయగలదన్నమాట. అవి కూడా చెప్తాం.
wavs/kb2B9_A3TxE_vocals00015197.wav,"ఇప్పుడు ఈ సినారియోలో మన inventory system అనేది serverలా act చేస్తుంది కదా, ఎందుకు request accept చేస్తుంది కాబట్టి, అది కూడా కొన్ని mechanisms వాడతన్నమాట. first mechanism ఏంటి అంటే..."
wavs/kb2B9_A3TxE_vocals00015426.wav,Rate limiting mechanism అంటే ఏంటంటే server ఏం చేస్తుందంటే చాలా requests దానికి రాకుండా అది rate limiting పెట్టుకుంటుందన్నమాట. అంటే నాకు ఇన్ని requests ఏ రావాలి అని చెప్పేసి.
wavs/kb2B9_A3TxE_vocals00015639.wav,"For example, let's say ఒక second కి ten thousand requests గాని లేకపోతే one lakh requests గాని అలా ఒక limit పెట్టుకుంటాం. So, అంతకన్నా ఎక్కువ requests రాలేవు. నువ్వు retrace చేసుకున్నా కూడాను అవి రాలేవు అనమాట. అదొక strategy."
wavs/kb2B9_A3TxE_vocals00015884.wav,rate limiting కాకుండా అది ఇంకో strategy వాడతాది. అదేంటి అంటే adaptive rate limiting అనమాట. ఇది ఇంకా బాగుంటది. అంటే ఏంటంటే
wavs/kb2B9_A3TxE_vocals00016070.wav,ఇప్పుడు నీ inventory ఉంది. నీ inventory అనేది regular గా గాను ఒక ten thousand requests per second handle చేస్తాది rate limiting పెట్టింది. Okay నా? ఇప్పుడు మెల్లమెల్లగా దాని మీద load పెరిగిపోతుంది. Load పెరిగిపోయి CPU గాని memory గాని అన్నీ fluctuations వస్తున్నాయి అనమాట.
wavs/kb2B9_A3TxE_vocals00016451.wav,fluctuations రాగానే ఈ adaptive rate limiting ఏమవుద్ధంటే CPU memory బట్టి అసలు ఆ time లో అది ఎన్ని requests ని handle చేయగలదు probably ten thousand చేయలేకపోవచ్చేమో probably five thousand చేయొచ్చేమో
wavs/kb2B9_A3TxE_vocals00016742.wav,"Five thousand limit పెడుతుందన్నమాట. So, ఒక్కసారిగా only నువ్వు five thousand requests మాత్రమే చేయగలవు అన్నమాట. అదే CPU memory ఇంకా పాడైపోతుంది అనుకో maybe two hundred requests చేయగలదేమో, అర్థమవుతుందా? So, constant గా ఇది rate limiting అనేది మార్చేసి ఉంటుందన్నమాట, దాని health metrics బట్టి"
wavs/kb2B9_A3TxE_vocals00017124.wav,సో ఈ విధంగా adaptive rate limiting వాడడం వల్ల systems అనేవి కొంచెం intelligent గా behave చేస్తాయన్నమాట
wavs/kb2B9_A3TxE_vocals00017261.wav,"last but not least ఏంటంటే resource restriction అనమాట. అంటే ఏంటి అంటే ఇప్పుడు నీ order system ఉంది, నీ inventory system ఉంది"
wavs/kb2B9_A3TxE_vocals00017441.wav,ఇప్పుడు ఏమవుద్ది అంటే inventory ఏమంటది అంటే inventory దగ్గర కొన్ని resources ఉంటాయి. for example CPU గాని memory గాని
wavs/kb2B9_A3TxE_vocals00017635.wav,"లేకపోతే thread pool ఉంటది. ప్రతి request ని handle చేయడం కోసం కొన్ని thread pool ఉంటది. For example inventory దగ్గర ఒక thousand thread pool ఉంది. అంటే, నువ్వు ఎన్ని request చేస్తే ఆ అన్నీ request ఈ ten thousand thread pools వాడకొని అది process చేస్తాది."
wavs/kb2B9_A3TxE_vocals00017957.wav,"ఇప్పుడు inventory ఏం చేస్తదంటే intelligent గానూ, నేను order కోసం కేవలం three hundred మాత్రమే ఇస్తాను"
wavs/kb2B9_A3TxE_vocals00018113.wav,ఓకే నా at the same time order కాకుండా let's say customer అని ఇంకోటి ఉంది. దానికి నేను కేవలం
wavs/kb2B9_A3TxE_vocals00018260.wav,"Two hundred ఏ ఇస్తాను. అలాగా అది budget చేస్తదనమాట restrict చేస్తది resources ని. ఆ order కి నేను three hundred ఏ ఇస్తాను, దీనికి two hundred ఇస్తా అని చెప్తాంది"
wavs/kb2B9_A3TxE_vocals00018455.wav,Order అనేది by mistake ఎక్కువ request చేద్దాం అన్నా అది allow చేయదు అనమాట. ఎందుకు? అది resources ని constrain చేసింది. నువ్వు ఇన్ని request ఏ చేయగలవు అని చెప్పేసి అని.
wavs/kb2B9_A3TxE_vocals00018636.wav,సో ఈ strategy వాడి కూడానూ server చాలా సార్లు retrace నువ్వు try చేస్తున్నా కూడాను నిన్ను restrict చేయగలదన్నమాట
wavs/kb2B9_A3TxE_vocals00018791.wav,సో overall గా నువ్వు observe చేస్తే client side ఉంది server side ఉంది. ఈ రెండు కూడాను different different strategies వాడి retrace వాడుతది. Retrace వాడినప్పుడు కూడాను వేరే వాళ్ళ మీద ఎక్కువ impact అవకుండా కూడా different different strategies వాడుతది అనమాట.
wavs/5rTRRIwfKNo_vocals00000000.wav,మా పాత కంపెనీలోనే ఒక back end engineer role అనేది మాకు అవసరం పడిందన్నమాట. so దానికోసం interview start చేశాము
wavs/5rTRRIwfKNo_vocals00000142.wav,సో interviews లోనే ఒక person ని నేను ఏమడిగానంటే Uber లాంటి system తీసుకొని అసలు దాంట్లో entities ఎలా ఉంటాయి? దాన్ని design ఒకసారి చెయ్యు అని అడిగానమాట
wavs/5rTRRIwfKNo_vocals00000315.wav,"అయితే ఆ పర్సన్ కాసేపు ఆలోచించాడు. ఆలోచించి తను ఏం చెప్పాడంటే ఒక driver ఉంటాడు, ఒక user ఉంటాడు, ఒక trip ఉంటది. ఇవే entities అన్నాడన్నమాట. అలా కాదు bro కొంచెం ఆలోచించు, ఆలోచించి చెప్పు అంటే లేదు bro ఇవే ఉంటాయి అన్నాడన్నమాట."
wavs/5rTRRIwfKNo_vocals00000585.wav,"[నవ్వు] లేదు bro చాలా entities ఉంటాయి, నువ్వు ఆలోచించట్లేదు అని చెప్పేసని ఆ person reject చేశాను అనమాట. The whole point ఏంటంటే, నేను general గా ఏం believe చేస్తాను అంటే back end engineering లోని entity designing అనేది one of the hardest skill అనమాట"
wavs/5rTRRIwfKNo_vocals00000876.wav,"అదెందుకు అంటున్నానంటే, for example let's say MySQL గాని లేకపోతే Redis లాంటి ఇలాంటి cache గాని ఇలాంటివి తీసుకోండి"
wavs/5rTRRIwfKNo_vocals00000997.wav,"ఇప్పుడు ఈ technologies అనేవి internally ఎలా work అవుతున్నాయని మనకు complete గా అర్థమైతే, అవి risk కూడా అలాగే work అవుతాయి. అంతేగాని మారిపోతూ ఉండవు."
wavs/5rTRRIwfKNo_vocals00001159.wav,కానీ అదే మీరు entity designing వచ్చేసరికి మీరు ఒక business కోసం కొన్ని entities create చేస్తే ఆ entities అనేవి business తో పాటు evolve అవుతూ ఉండాలనమాట
wavs/5rTRRIwfKNo_vocals00001347.wav,"అంతేగాని అలా stagnant గా ఉండిపోకూడదు. సో, అందుకే entity designing అనేది కొంచెం tricky part అన్నమాట."
wavs/5rTRRIwfKNo_vocals00001501.wav,"Hey, hi everyone, this is Shabri. నేను Learning Grass అనే startup లోని CTO కింద work చేస్తున్నాను. ఈ video లో నేను ఏం చేస్తాను అంటే Uber లాంటి ఒక system తీసుకుని అసలు ఆ system లోని entity designing ఎలా ఉంటది, ఎలాంటి entities ఉంటాయి అనే దాని మీద discuss చేస్తాను."
wavs/5rTRRIwfKNo_vocals00001798.wav,"అసలు entity అంటే ఏంటి? See, general గా చాలా మంది ఏమనుకుంటారంటే entity అంటే database table అనుకుంటారన్నమాట. Which is not completely true. For example, మనం చాలా fundamental గా ఆలోచిస్తే, first business ఉంటది. Business కోసం మనం ఇదంతా చేస్తున్నాం."
wavs/5rTRRIwfKNo_vocals00002091.wav,business కింద ఏముంటది అంటే business concepts ఉంటాయి అన్నమాట. ఈ business concepts use చేస్తే business అనేది run అవుతది. ఈ business concepts కింద entity layering ఉంటది అన్నమాట.
wavs/5rTRRIwfKNo_vocals00002317.wav,ఈ business concepts use చేసే మన entities ని design చేస్తాం అనమాట. ఈ entities ని మన data base లో store చేస్తాం అనమాట. so entities కి data base కి అసలు ఎలాంటి relation లేదనమాట. అసలు entities design చేస్తున్నప్పుడు మనం data base కోసం ఆలోచించాల్సిన అవసరం కూడా లేదు.
wavs/5rTRRIwfKNo_vocals00002609.wav,సో ఇప్పుడు ఎవరైనా దగ్గరికి వచ్చి Uber లాంటి system design చేయమంటే నేను fundamental గా ఎలా ఆలోచిస్తానంటే అసలు నేనే ఒక Uber లాంటి company run చేస్తే అసలు flow ఎలా ఉంటది అనేది first నేను రాసుకుంటాను అనమాట. సో first నేను ఏం చేస్తానంటే proper flow రాసుకుంటాను.
wavs/5rTRRIwfKNo_vocals00002916.wav,"Second ఏం చేస్తానంటే, ఆ flow లోనే ఉన్న different domains ని figure out చేస్తా అనమాట. Third thing ఏంటి అంటే, ప్రతి domain యొక్క responsibilities ఏంటి? ఆ responsibilities చూస్ చేసి ఎలాంటి business concepts అది వాడుతుంది అనేది figure out చేస్తా అనమాట."
wavs/5rTRRIwfKNo_vocals00003220.wav,"Fourth thing ఏంటంటే, ఆ business concepts responsibilities choose చేసి entities ని create చేస్తాం"
wavs/5rTRRIwfKNo_vocals00003338.wav,సో ఈ four steps ని వాడి నేను general గా entities అనేది design చేస్తానన్నమాట. సో ఇప్పుడు మనం first step కి వద్దాం
wavs/5rTRRIwfKNo_vocals00003505.wav,నేను ఇప్పుడు Uber company run చేస్తున్నాను అంటే first నేను ఆ area లో ఉన్న drivers ని onboard చేసుకోవాలి
wavs/5rTRRIwfKNo_vocals00003650.wav,"drivers ని onboard చేయాలి అంటే, నేను first వాళ్ళ personal details figure out చేస్తా అన్నమాట. ఏంటి? Aadhar card గాని PAN card గాని వాళ్ళ personal details తీసుకుంటా."
wavs/5rTRRIwfKNo_vocals00003848.wav,దాని తర్వాత driving వచ్చా లేదా అని చెప్పేసి driving license యొక్క document అనేది చూస్తాం. దాని తర్వాత ఆ person దగ్గర ఏ vehicle వాడుతున్నాడో ఆ vehicle యొక్క documents తీసుకుంటాం.
wavs/5rTRRIwfKNo_vocals00004077.wav,ఆ vehicle documents use చేసి దానికి registration గాని insurance గాని ఇలాంటి documents అన్ని తీసుకుంటాం. first document collection అనేది చేస్తాం. చేసిన తర్వాత ఆ documents ని proper గా నేను verify చేస్తాను. అన్ని correct గా ఉన్నాయా లేదా అని చెప్పేసి.
wavs/5rTRRIwfKNo_vocals00004376.wav,"Verify చేసిన తర్వాత నేను driver అనే వాడిని onboard చేస్తాను. So, ఇప్పుడు driver అనేవాడు నాకు onboard అయిపోయాడు. Next నేను ఏం చేస్తాను? User ని onboard చేసుకోవాలి. User ని onboard చేయడానికి నాకు అంత పెద్ద హంగామా ఏం లేదన్నమాట. Basic గా ఒక phone number, name, email ఇలాంటివి తెలుసుకుంటే నేను user అనేవాడిని onboard చేసుకోవచ్చు."
wavs/5rTRRIwfKNo_vocals00004791.wav,సో ఇప్పుడు నేను driver ని onboard చేశాను user ని onboard చేశాను next నేను ఏం చేస్తానంటే user అనేవాడికి ఒక app ఇచ్చేసి ఆ app లోని user ఏం చేస్తాడంటే start location end location పెట్టగానే నేను వాడికి ఒక price card చూపించాలన్నమాట
wavs/5rTRRIwfKNo_vocals00005119.wav,price card అంటే ఏంటి? అసలు ఆ start location కి end location కి కార్ అయితే ఎంత cost అవుతది? లేకపోతే ఒక bike అయితే ఎంత cost అవుతది? లేకపోతే ఒక bus అయితే ఎంత cost అవుతది?
wavs/5rTRRIwfKNo_vocals00005354.wav,ఇలాగ different vehicles కి ఎంత rate ఉంది అని చెప్పేసని వాడికి ఒక నేను rate card చూపించాలి అనమాట
wavs/5rTRRIwfKNo_vocals00005492.wav,ఓకే ఇప్పుడు user ఏం చేస్తాడు? ఏదో ఒక rate card లోని ఒక vehicle select చేసుకుని వాడు ride request generate చేస్తాడన్నమాట. అంటే ఏంటంటే నాకు ఇప్పుడు ride కావాలి అని చెప్పేసి అని request generate చేస్తాడు.
wavs/5rTRRIwfKNo_vocals00005779.wav,"generate చేసిన తర్వాత Uber అనే వాడు ఏం చేస్తాడంటే, నీ request ని తీసుకుని, వాడి దగ్గర కొంతమంది drivers ఉంటారు కదా, ఆ drivers అందరికి నీ request ని పంపిస్తారన్నమాట."
wavs/5rTRRIwfKNo_vocals00005990.wav,మీ request ని పంపిస్తే దాంట్లో ఎవరో కొంతమంది driver అనే వాళ్ళు accept చేస్తారు
wavs/5rTRRIwfKNo_vocals00006109.wav,"ఓకే నా, drivers అందరికీ పంపిస్తాడు. ఇప్పుడు ఆ drivers కొంతమంది accept చేస్తారు, కొంతమంది reject చేస్తారు."
wavs/5rTRRIwfKNo_vocals00006233.wav,అదే ఇప్పుడు driver ఒకవేళ accept చేశారనుకోండి accept చేస్తే మేము ఏం చేస్తామంటే మీ కోసం ఒక trip అనేది create చేస్తాడు Uber వాడు
wavs/5rTRRIwfKNo_vocals00006383.wav,"ఓకే, ఇప్పుడు ట్రిప్ create అయిన తర్వాత నేను driver కి ఏం చెప్తానంటే, ""అరే driveru! నువ్వు ఈ location కి వెళ్ళు. ఈ time కి వెళ్ళి ఈ customer ని pickup చేసుకో. pickup చేసుకుని ఇక్కడ drop చేయు"" అని చెప్తానన్నమాట."
wavs/5rTRRIwfKNo_vocals00006643.wav,అంతే కదా! చెప్పిన తర్వాత driver ఏం చేస్తాడు? ఆ time కి నేను చెప్పిన location కి వస్తాడు. వచ్చిన తర్వాత ప్రతి driver కి నేను కొన్ని OTPs ఇస్తాను అన్నమాట ఆ trip కి. so ఇప్పుడు customer ఏం చేయాలంటే driver కి ఆ OTP చెప్పి ఆ ride ని అనేది verify చేసుకో.
wavs/5rTRRIwfKNo_vocals00006981.wav,Verify చేసిన తర్వాత ఆ trip అనేది start అవుతుంది. Trip start అయిన తర్వాత trip మధ్యలో ఏమైనా issues ఉన్నాయనుకోండి customer అనేవాడు raise చేయొచ్చన్నమాట trip మధ్యలో ఏమైనా issues ఉంటే.
wavs/5rTRRIwfKNo_vocals00007199.wav,"Trip అనేది complete గా ఎప్పుడు end అవుతది? ఎప్పుడైతే మన ఒక end location reach అయిపోతామో అప్పుడు trip, trip అనేది complete అయిపోతుంది అన్నమాట."
wavs/5rTRRIwfKNo_vocals00007358.wav,ట్రిప్ complete అయిపోగానే మనం ఏం చేయాలి? డ్రైవర్ కి pay చేయాలి. ఇప్పుడు let's say నేను Uber app use చేసుకొని driver అనే వాడికి pay చేస్తాను అనమాట.
wavs/5rTRRIwfKNo_vocals00007544.wav,ఇప్పుడు Uber వాళ్ళు ఏం చేయాలి? నేను pay చేసిన amount లోని కొంత percentage వాళ్ళు ఉంచుకొని driver కి కొంత percentage ఇవ్వాలి.
wavs/5rTRRIwfKNo_vocals00007728.wav,"సో ఈ విధంగా complete trip అనేది work అవుద్ది అనమాట. సో నువ్వు observe చేస్తే Uber మొత్తం ఏం చేస్తుందంటే, ఈ particular flow నే loop లో run చేస్తూ ఉంటుందన్నమాట ప్రతి రోజును"
wavs/5rTRRIwfKNo_vocals00007960.wav,సో first understanding flowతో అర్థమైపోయింది. ఇప్పుడు నేను ఏం చేస్తానంటే ఈ flow ని use చేసుకుని domains ని figure out చేస్తానన్నమాట
wavs/5rTRRIwfKNo_vocals00008169.wav,domains అంటే ఏంటి అంటే for example ఈ flow మొత్తం run చేయడం కోసం నాకు అసలు ఎలాంటి teams కావాలి అని first figure out చేస్తాను
wavs/5rTRRIwfKNo_vocals00008362.wav,For example మీరు first observe చేస్తే first ఈ ఐదు steps లోని ఏం చేస్తున్నాను అంటే driver ని onboard చేసుకోవడం user ని onboard చేసుకోవడం.
wavs/5rTRRIwfKNo_vocals00008574.wav,"ఇలాంటి పనులే చేస్తాను. సో, ఇలాంటి పనుల కోసం నేను ఒక onboarding team పెట్టుకుంటాను అనమాట"
wavs/5rTRRIwfKNo_vocals00008710.wav,"ఓకే. ఈ onboarding team పనులేంటంటే necessary documents collect చేయడం, వాటిని verify చేయడం, వాళ్ళని onboard చేయడం. ఇది onboarding team యొక్క పని, ఆ responsibilities."
wavs/5rTRRIwfKNo_vocals00008927.wav,"Next నేను ఏం చేస్తానంటే, ఈ six to seven, eight, seven, eight responsibilities కోసం ఒక pricing team పెడతానన్నమాట"
wavs/5rTRRIwfKNo_vocals00009104.wav,"ఓకే pricing team పని ఏంటి అంటే, నువ్వు ఒక start location end location ఇవ్వగానే వాళ్ళు నీకు ఒక rate card ఇస్తారన్నమాట"
wavs/5rTRRIwfKNo_vocals00009274.wav,"ఆ rate card figure out చేయడం కోసం వాళ్ళ దగ్గర different different parameters ఉంటాయి. For example పెట్రోల్ rate పెరిగిందా లేదా, ఎన్ని kilometers, popular area కాదా, vehicle type ఏంటి?"
wavs/5rTRRIwfKNo_vocals00009499.wav,ఇలాంటి different different parameters use చేసుకొని వాళ్ళు pricing define చేస్తారన్నమాట
wavs/5rTRRIwfKNo_vocals00009609.wav,"సో, వా ఈ pricing team దగ్గర అలాంటి skill ఉంటది. Okay price determine చేయగలిగే skill ఉంటదన్నమాట"
wavs/5rTRRIwfKNo_vocals00009725.wav,ఇప్పుడు మీరు ninth to tenth observe చేస్తే వాళ్ళు ఏం చేస్తారంటే నువ్వొక request raise చేయగానే వాళ్ళు నీ కోసం driver ని వెతుకుతారన్నమాట
wavs/5rTRRIwfKNo_vocals00009907.wav,"ఓకే. సో, దీన్ని నేనేమంటానంటే driver matching team అంటానన్నమాట"
wavs/5rTRRIwfKNo_vocals00010028.wav,"సో, ఈ team యొక్క skill ఏంటి అంటే, నువ్వొక request చేయగానే, నీ request బట్టి నీకు మంచి driver ఇవ్వాలా, తక్కువ-తక్కువ cost ఉన్న driver ఇవ్వాలా, దగ్గరున్న driver ఇవ్వాలా లేకపోతే female driver ఇవ్వాలా, male driver ఇవ్వాలా"
wavs/5rTRRIwfKNo_vocals00010301.wav,"ఎక్కువ rating ఉన్న driver ఇవ్వాలా, ఇలా different parameters choose చేసుకొని వాళ్ళు decision తీసుకుంటారన్నమాట. వాళ్ళు driver matching team అన్నమాట."
wavs/5rTRRIwfKNo_vocals00010479.wav,వాళ్ళు నీ కోసం ఒక driver select చేయగానే next ఇంకో team అనేది ఈ eleven to fourteen యొక్క responsibilities చేస్తారన్నమాట
wavs/5rTRRIwfKNo_vocals00010640.wav,"ఆ team ని ఏమంటాను అంటే trip team అంటాన్నమాట. ఈ trip team ఏం చేస్తారు అంటే, మీ trip start అవగానే అసలు driver మీ location కి చేరాడా లేదా? OTP correct గా verify అయిందా లేదా?"
wavs/5rTRRIwfKNo_vocals00010889.wav,"ట్రిప్ అవుతున్నంత సేపు నీకేమైనా problems వస్తున్నాయా లేదా, ట్రిప్ complete అయిపోయిందా లేదా correct time కి, ఇలాంటి things అన్ని ఈ ట్రిప్ team manage చేస్తారన్నమాట. Okay నా? దాని తర్వాత final గా ఏమొస్తుందంటే payments team వస్తుందన్నమాట."
wavs/5rTRRIwfKNo_vocals00011192.wav,ఈ payments team పని ఏంటి అంటే trip complete అయిపోగానే customer driverకి pay చేసాడా లేదా customer pay చేసిన తర్వాత మనం మళ్ళీ driverకి pay చేసామా లేదా ఇలాంటి payment related things అన్నినూ ఈ payments team చూసుకుంటది అనమాట.
wavs/5rTRRIwfKNo_vocals00011496.wav,సో ఇక్కడ observe చేస్తే different teams ని hire చేశాను. ప్రతి team కి ఒక specific skill set ఉంది. ఒక కొన్ని responsibilities ఉన్నాయన్నమాట
wavs/5rTRRIwfKNo_vocals00011665.wav,"సో దీన్నే నేను domains అంటానన్నమాట. ప్రతి team ని ఒక domain అంటానన్నమాట. Okay సో final గా domain అంటే ఏంటి అంటే, ప్రతి domain కి ఒక specific set of responsibilities ఉంటాయి. ఆ domain లో ఉన్న వాళ్ళందరికిని ఒక specific skill set ఉంటాదన్నమాట."
wavs/5rTRRIwfKNo_vocals00011992.wav,"రెండు domains ఎప్పుడూ అంత easyగా కలవవు అనమాట separate, separateగా ఉంటాయి. Okay నా? ఇప్పుడు domains figure out చేశాను కదా"
wavs/5rTRRIwfKNo_vocals00012249.wav,"domains figure out చేసిన తర్వాత domains అన్నిటినీ ఇలా రాసుకున్నాను అనమాట. Okay నా? On-boarding domain అని, pricing domain అని, driver matching domain అని, trip domain అని payments domain అని"
wavs/5rTRRIwfKNo_vocals00012440.wav,"ఇప్పుడు onboarding domainలోకి వెళ్తే onboarding domainలో ఉన్న teamకి ఏం పని ఉంటాదండి? మీరు observe చేస్తే వాళ్ళ పని ఏంటంటే మీరు driverని onboard చేసుకోవాలి, documents collect చేసుకుని అలాగే userని onboard చేసుకోవాలి. ఇది వాళ్ళ పని."
wavs/5rTRRIwfKNo_vocals00012761.wav,"ఇప్పుడు దాన్ని నేను business concept లా మాట్లాడుకుంటే నేనేం చెప్తానంటే, అరే onboarding team మీకు ఒక onboarding request వస్తది"
wavs/5rTRRIwfKNo_vocals00012973.wav,"Onboarding request అంటే ఏంటి అంటే user అనేవాడు let's say ఒక driver అనేవాడు నేను మీ platform లో onboard అవుదాం అనుకుంటున్నాను. నా documents ఇవి, నా vehicle documents ఇవి అని చెప్తాడు. దాన్ని onboarding request అంటున్నారన్నమాట"
wavs/5rTRRIwfKNo_vocals00013289.wav,Onboarding request ని ఇప్పుడు onboarding team ఏం చేయాలి? Onboarding request మొత్తం verify చేసి అసలు ఇది success ఆ failure ఆ accept ఆ reject ఆ ఇలాంటి things అన్నీ measure చేయాలన్నమాట
wavs/5rTRRIwfKNo_vocals00013507.wav,ఎప్పుడైతే onboarding team అదంతా చేస్తదో accept చేస్తే అప్పుడు దాని నుంచి driver వస్తాడన్నమాట. ఇది business concept. ఈ business concept use చేసుకునే మనం entities కూడా create చేస్తామన్నమాట.
wavs/5rTRRIwfKNo_vocals00013854.wav,సో మన first entity మనం ఏం create చేస్తామంటే onboarding request అన్నమాట. ఏం onboarding request? Driver onboarding request అన్నమాట
wavs/5rTRRIwfKNo_vocals00014021.wav,"Driver అనే వాడు నా name ఇది, నా phone number ఇది, నా email ఇది, నా aadhaar details ఇది, నా PAN card details ఇది, నా vehicle details ఇది"
wavs/5rTRRIwfKNo_vocals00014205.wav,"Vehicle details లో ఏముంటది? Vehicle number ఇది, vehicle type ఇది, vehicle registration details, vehicle insurance details"
wavs/5rTRRIwfKNo_vocals00014358.wav,ఈ details అన్నీ ఇచ్చి నేను on board అవ్వచ్చా అని మనల్ని అడుగుతాడు. ఆ ఆ flow మొత్తం ఈ driver on board request handle చేస్తాడన్నమాట.
wavs/5rTRRIwfKNo_vocals00014553.wav,ఇప్పుడు దీంట్లో status అనే ఒక variable ఉంటాదన్నమాట. ఇది ఏం చేస్తుందంటే driver initiate చేయగానే driver request చేయగానే initiated status లో ఉంటాదన్నమాట.
wavs/5rTRRIwfKNo_vocals00014759.wav,"ఓకే initiate status లో ఉంటది. దాని తర్వాత ఎప్పుడైతే మన onboarding team ఆ documents అన్ని verify చేస్తదో, let's say అది document approved stage లోకి వెళ్తది అనమాట."
wavs/5rTRRIwfKNo_vocals00015018.wav,"ఓకే, అదే ఒకవేళ reject చేసింది అనుకోండి rejected status లో direct గా వెళ్ళిపోతాది. Rejected status లో direct గా వెళ్ళిపోగానే probably driver అనేవాడు వేరే request చేసుకోలేము onboarding request."
wavs/5rTRRIwfKNo_vocals00015291.wav,"అర్థమవుతుందా? అదే ఇప్పుడు documents proper గా approve అయిపోయింది అనుకోండి, దానికి అర్థం ఏంటంటే, మీ request అనేది approve అయిపోయింది అని అర్థం అన్నమాట."
wavs/5rTRRIwfKNo_vocals00015454.wav,సో ఈ విధంగా నీ driver onboarding request అనేది approve అవ్వగానే driver అనేవాడు ఒకడు create అవుతాడన్నమాట.
wavs/5rTRRIwfKNo_vocals00015619.wav,"ఓకే. డ్రైవర్ లో ఏముంటది? డ్రైవర్ నేమ్ ఉంటది, వాడి బేసిక్ పాన్ కార్డ్ details, vehicle details, phone numbers ఇవన్నీ ఉంటాయి. ఇవన్నీ verified అనమాట."
wavs/5rTRRIwfKNo_vocals00015802.wav,Verified data మాత్రమే driver లో ఉంటది. On-boarding request లో అలా కాదు. అసలు user ఏమిచ్చాడో ఆ data మొత్తం ఉంటదన్నమాట
wavs/5rTRRIwfKNo_vocals00015957.wav,సో ఈ రెండు entities ని proper గా ఎవరు వాడతారు? on-boarding team అనేది వాడతన్నమాట.
wavs/5rTRRIwfKNo_vocals00016069.wav,"So, Onboard team driver create చేసింది, Onboard request create చేసింది. Next user ని కూడా create చేసిందన్నమాట. User కి ఏముంటది? User లో ఒక name ఉంటది, phone ఉంటది, email ఉంటది, let's say age ఉంటదనుకుందాం."
wavs/5rTRRIwfKNo_vocals00016304.wav,"ఓకే basic details ఏ ఉంటాయి? user ki onboarding కోసం specific process అంటూ ఏం లేదన్నమాట. ఒకవేళ process ఉందనుకోండి, వాడు కూడా కొన్ని documents submit చేయాలనుకోండి, అప్పుడు probably user onboarding request అని మనం వేరొకటి create చేసుకుంటాం."
wavs/5rTRRIwfKNo_vocals00016592.wav,"కానీ ఇక్కడ అలాంటి life cycle లేదు కాబట్టి simple గా user ని మనం create చేస్తాం. so ఈ entities తోని మన user domain, onboarding domain యొక్క responsibility అయిపోయిందన్నమాట"
wavs/5rTRRIwfKNo_vocals00016816.wav,ఇప్పుడు online demand పని అయిపోగానే next ఏమొద్దంటే pricing domain లోకి వెళ్తాదన్నమాట
wavs/5rTRRIwfKNo_vocals00016930.wav,"Pricing domain లో పని ఏంటి? నీకు ఎవరైనా రెండు locations ఇచ్చేసి price చెప్పమంటే, నువ్వు different vehicles యొక్క rate card ఇవ్వాలి. అది దాని responsibility."
wavs/5rTRRIwfKNo_vocals00017133.wav,ఇప్పుడు ఏం చేస్తాడు user అనేవాడు? first ఒక request చేస్తాడన్నమాట price request pricing request చేస్తాడు
wavs/5rTRRIwfKNo_vocals00017256.wav,ఏంటంటే వాడు ఒక start location ఇస్తాడు end location ఇస్తాడు. End location ఎవరు ఇస్తారు? ఏ user ఇచ్చాడు
wavs/5rTRRIwfKNo_vocals00017403.wav,"ఏ start location, ఏ end location ఇలాగ ఒక pricing request అనేది ఒకటి create అవుతుంది. అది కూడా ఒక entity యే. ఇప్పుడు ఈ pricing request కి మన pricing domain లో team అంతా ఏం చేస్తారంటే మీకు ఒక rate card ఇస్తారు."
wavs/5rTRRIwfKNo_vocals00017676.wav,"ఈ రేట్ కార్డ్ లో ఏముంటాది అంటే different vehicle type ఏంటి? దాని cost ఏంటి? bus అయితే ఇంత cost, van అయితే ఇంత cost, bike అయితే ఇంత cost అని ఇస్తారు."
wavs/5rTRRIwfKNo_vocals00017881.wav,"సో, ఈ pricing domain లో ఈ రెండు entities ఉంటాయి అనమాట. ఏంటంటే ఒకటి pricing request అంటే ఏ user request చేశాడు, ఏ location request చేశాడు."
wavs/5rTRRIwfKNo_vocals00018062.wav,రెండవది ఏంటంటే rate card. ఆ request కి నువ్వు అసలు ఏమి rate card ఇచ్చావు అనేది.
wavs/5rTRRIwfKNo_vocals00018193.wav,ఈ రెండింటితోనీ మన pricing domain అనేది deal చేస్తాన్నమాట. ఇప్పుడు నువ్వు rate card చూపించగానే user ఏం చేస్తాడు? ఏదో ఒక vehicle select చేసుకొని user ఏం చేస్తాడంటే...
wavs/5rTRRIwfKNo_vocals00018432.wav,Trip request చేస్తాడన్నమాట. నాకు ఇలా ఒక trip కావాలి అని చెప్పేసి అని user request చేస్తాడు. Okay నా? ఇప్పుడు ఆ trip request అనేది ఎవరి domain లోకి వచ్చేస్తాది?
wavs/5rTRRIwfKNo_vocals00018653.wav,Driver matching domain లోకి వచ్చేస్తాం అంట. Driver matching domain లోని team పని ఏంటి? నీ request తీసుకుని నీకు ఒక driver ని assign చెయ్యాలి. అదే కదా వాళ్ళ పని
wavs/5rTRRIwfKNo_vocals00018842.wav,సో ఆ పని చేయడం కోసం first వాళ్ళు ఏం చేస్తారంటే ఈ trip request చూస్తారు. ఈ trip request లో ఏమేం parameters ఉంటాయి? start location ఏంటి? end location ఏంటి? ఎంత cost select చేసుకున్నాడు?
wavs/5rTRRIwfKNo_vocals00019083.wav,"ఏ user select చేసుకున్నాడు, ఎవరా user? Vehicle mode ఏంటి? అండ్ status. ఎప్పుడైతే నువ్వు request చేస్తావో అప్పుడు నీ status అనేది let's say initiated లో ఉంటది"
wavs/5rTRRIwfKNo_vocals00019351.wav,"అంటే ఏంటంటే, నువ్వు ఇంకా request raise చేశావని అర్థం అన్నమాట. దాని తర్వాత అది completed లోకి ఎప్పుడెళ్తది? ఎప్పుడైతే నీకు ఒక ఆ driver ని assign చేస్తామో, అప్పుడది completed లోకి వెళ్తది. ఒకవేళ నీకు assign చేయలేదు అనుకో, అది rejected లోకి వెళ్లిపోద్ది అన్నమాట."
wavs/5rTRRIwfKNo_vocals00019711.wav,"సో, ఈ driving domain, driver matching domain పని ఏంటి అంటే దీన్ని complete చేయడం"
wavs/5rTRRIwfKNo_vocals00019842.wav,complete చేయడం కోసం అది ఏం చేస్తది అంటే ప్రతి driver కి call చేస్తది request పంపిస్తది. ఆ request ని మనం ఏమంటాం అంటే driver request అంటాం అనమాట.
wavs/5rTRRIwfKNo_vocals00020056.wav,ఈ driver request లో ఏముంటదంటే అసలు ఏ trip request కోసం నువ్వు driver request create చేశావు అని ఉంటదన్నమాట
wavs/5rTRRIwfKNo_vocals00020208.wav,"ఓకే నా, ఏ driver కి పంపిస్తున్నావు? ఏ time కి పంపించావు? ఓకే నా, ఇప్పుడు status ఏంటి?"
wavs/5rTRRIwfKNo_vocals00020370.wav,"Status లో ఏముంటది? Driver accept చేయొచ్చు, reject చేయొచ్చు."
wavs/5rTRRIwfKNo_vocals00020505.wav,ఓకే నా! ఇప్పుడు నువ్వొక వంద మంది drivers ని call చేస్తావు-- పంపించావు అంటే వాళ్ళందరి thing ఇక్కడ store అయి ఉంటాదన్నమాట
wavs/5rTRRIwfKNo_vocals00020689.wav,"ఒక ట్రిప్ రిక్వెస్ట్, ఆ ట్రిప్ రిక్వెస్ట్ కి multiple driver requests ఉంటాయి అనమాట. ఇప్పుడు నీకు let's say ఒక driver accept చేసాడు. Accept చేయగానే నీ ట్రిప్ రిక్వెస్ట్ అనేది initiated status నుంచి completed లోకి వెళ్ళిపోయింది."
wavs/5rTRRIwfKNo_vocals00020961.wav,Completed లోకి వెళ్ళిపోగానే నువ్వు driver matching domain దగ్గర నుంచి trip domain లోకి వెళ్ళిపోతావ్
wavs/5rTRRIwfKNo_vocals00021095.wav,Trip domain లో ఏముంటది అంటే trip ఉంటాదన్నమాట. ఓకే నా? ఈ trip అనేది ఎలా ఉంటది అంటే initial గాను initiated status లో ఉంటది.
wavs/5rTRRIwfKNo_vocals00021295.wav,"ఇప్పుడు ట్రిప్ డొమైన్ లో ఉన్న పని ఏంటి అంటే, నీ ట్రిప్ ని initiate లో ఉంది కదా, దాన్ని"
wavs/5rTRRIwfKNo_vocals00021426.wav,End state కి పట్టుకెళ్లాలన్నమాట. అంటే ఏంటి? Either complete పట్టుకెళ్లాలి లేకపోతే ఆ cancel కి పట్టుకెళ్లాలి.
wavs/5rTRRIwfKNo_vocals00021594.wav,ఈ రెండు పట్టికలను ఆ Tripdom యొక్క రెస్-- టీం యొక్క responsibility అన్నమాట
wavs/5rTRRIwfKNo_vocals00021703.wav,ఇప్పుడు ఈ ట్రిప్పులో ఏముంటాయి? అసలు నువ్వు starting location ఏంటి? ending location ఏంటి? అసలు ఆ ట్రిప్ యొక్క cost ఎంత? fare details అంటాం cost ఎంత?
wavs/5rTRRIwfKNo_vocals00021928.wav,ఏ driver ఈ trip లో ఉన్నాడు? ఆ driver ఏ vehicle తో ఉన్నాడు? ఏ user ని ఆ driver drop చేస్తున్నాడు?
wavs/5rTRRIwfKNo_vocals00022089.wav,అలాగ ఈ ట్రిప్ యొక్క OTP ఏది-- ఏంటి? ఈ ట్రిప్ యొక్క status ఏంటి? చెప్పాగా ఇందాక initial గా ట్రిప్ అనేది initial గా initiated status లో ఉంటది. తర్వాత completed status ఇలాగ. ఆ status ఇక్కడ store చేసుకుంటాం.
wavs/5rTRRIwfKNo_vocals00022342.wav,దాని తర్వాత ఈ trip ఒకవేళ complete అయిపోయింది అనుకోండి complete అయిపోయిన తర్వాత అసలు payment details ఏంటి? అసలు ఏ mode లో pay చేసావు నువ్వు? Okay నా?
wavs/5rTRRIwfKNo_vocals00022574.wav,లేకపోతే ఎంత amount ఇదంతా ఈ trip payment details ఉంటది. ఇక్కడ మీరు observe చేస్తే trip event అని ఒకటి ఉందన్నమాట. అదేంటి అంటే
wavs/5rTRRIwfKNo_vocals00022767.wav,ఈ ట్రిప్ లోని different events జరుగుతుంటాయి అనమాట different events ఏమేం జరుగుతుంటాయి first event ఏంటి driver అనే వాడు location కి reach అయిపోయాడు
wavs/5rTRRIwfKNo_vocals00022955.wav,second event ఏంటి? rider అనే వాడు location reach అయిపోయాడు. third event ఏంటి? OTP verify అయిపోయింది. fourth event ఏంటి? trip complete అయిపోయింది. ఇలాగ different different events అన్నీ జరుగుతూ ఉంటాయి అనమాట.
wavs/5rTRRIwfKNo_vocals00023228.wav,"సో, మనం దాన్ని easy గా ఆ events అన్ని store చేసుకోవడం కోసం trip event అని ఒకటి పెట్టుకున్నాం ఒక entity. ఆ trip event లో ఏముంటాయి అంటే, అసలు event type ఏంటి? ఎలాంటి type of event? ఏ time కి జరిగింది ఆ event?"
wavs/5rTRRIwfKNo_vocals00023519.wav,ఇంక extraవి కూడా పెట్టుకోవచ్చు but simpleగా ఇవి అనుకోండి. so thing ఏంటంటే ఇప్పుడు trip అనేది ఎప్పుడైతే payment అయిపోతదో అప్పుడు నీ trip అనేది complete అయిపోతుందన్నమాట. so ఈ విధంగా trip domain లోని పని అంతా అవుద్దనమాట.
wavs/5rTRRIwfKNo_vocals00023799.wav,ఇప్పుడు ఎప్పుడైతే ట్రిప్ అయిపోతదో నెక్స్ట్ పని అనేది payments domainలోకి వెళ్తాంమాట. Payments domain పని ఏంటంటే ఇప్పుడు payment అనేది ఉబర్ అనేవాడు collect చేస్తున్నాడు.
wavs/5rTRRIwfKNo_vocals00024016.wav,collect చేసుకున్న తర్వాత ఆ payment ని driver కి కూడా ఇవ్వాలన్నమాట. ఆ ఇవ్వడం కోసం driver earnings let's say దీని కోసం ఏదో ఒక పేరు అనుకోండి driver earnings అని ఒక పేరు అనుకోండి
wavs/5rTRRIwfKNo_vocals00024238.wav,ఆ పేరులో ఏంటి అంటే ఇప్పుడు payment ఎప్పుడైతే నువ్వు finish చేసావో అప్పుడు driver కి ఒక wa-wallet ఉంటది అనుకోండి ఆ wallet లో create అవుతుంది ఏంటంటే ఇలాగ ఒక కొంత amount
wavs/5rTRRIwfKNo_vocals00024471.wav,"ఈ specific reason కోసం, ఈ trip ID కోసం, ఈ earning ఈ date రోజు credit అయింది"
wavs/5rTRRIwfKNo_vocals00024646.wav,అనేది అవుద్ది అనమాట. Okay. So దీంతో పాటు వేరే entities కూడా ఉంటాయి but the whole payments domain యొక్క పని ఏంటి అంటే
wavs/5rTRRIwfKNo_vocals00024815.wav,"వాటి కోసం మనం కొన్ని entities create చేస్తాం. Entities పని ఏంటి అంటే need-- ఆహ్ customer pay చేసిన amount ని driver కి మళ్ళీ ఛార్జ్-చార్చాలన్నమాట. వాళ్ళు ఆ responsibility మొత్తం తీసుకుంటారు. Okay? దీని కోసం ఇంకా లోపలికి వెళ్ళొచ్చు, నేను కావాలని వెళ్ళట్లేదు."
wavs/5rTRRIwfKNo_vocals00025128.wav,"సో, ఇప్పుడు మీరు observe చేస్తే ఇలాగ different domains అన్నీ ఉంటాయన్నమాట. ఈ different domains అన్నీ interact అయ్యి మీకు different entities అన్నీ వచ్చాయన్నమాట"
wavs/5rTRRIwfKNo_vocals00025317.wav,"ఇప్పుడు నీకు ఏమనిపిస్తుంది? ఇనిటీ సెట్ కరెక్ట్ అనుకుంటున్నావా? కాదన్నమాట. ఎందుకంటే, for example, let's say ఇప్పుడు నువ్వు మన, మన use case కైతే ఇనిటీ సెట్ అయ్యే"
wavs/5rTRRIwfKNo_vocals00025541.wav,"కాకపోతే ఇప్పుడు Uber అనేవాడు ఒకడు sudden గా వచ్చి అన్నాడు ""అరేయ్ శబరీ అంతా బానే ఉందరా మనం కొత్తగా Uber Pool అనే concept start చేద్దాం రా Uber Pool ఏమొద్దంటే ఒకటే trip లోని multiple people ఉంటార్రా వెళ్తారు"" అంటారన్నమాట. అంటే multiple people కి multiple start locations and end locations ఉంటాయి."
wavs/5rTRRIwfKNo_vocals00025915.wav,ఇప్పుడు ఇది అనగానే మనトリప్ ఎంటిటీ మొత్తం break అయిపోయిందన్నమాట. ఎందుకు? మన tripe entity ఏం చేసాము? ఒక start location ఒక user కి పెట్టాము. కాకపోతే ఊ pool లోని multiple people ఉంటారన్నమాట. so entity break అయిపోయింది.
wavs/5rTRRIwfKNo_vocals00026247.wav,"ఇది first thing. Second thing ఏమననంటే, trip కి నువ్వు payment తీసుకుంటున్నావ్"
wavs/5rTRRIwfKNo_vocals00026376.wav,బానే ఉంది కానీ ఒకడు అన్నాడు ఒరేయ్ వెంట వెంటనే customer దగ్గర payment తీసుకోవద్దు మనం ఏం చేద్దాం అంటే customer trips complete చేసేయని మనం ఏం చేద్దాం అంటే separate గాను ఒక five trips కి ఒకేసారి payment తీసుకుందాము లేకపోతే ten trips కి ఒకేసారి payment తీసుకుందాము payments అనేవి
wavs/5rTRRIwfKNo_vocals00026715.wav,ఒకటే payment multiple trips తీసుకుందాం అన్నాడన్నమాట. అప్పుడు కూడా ఈ entities break అయిపోతాయన్నమాట
wavs/5rTRRIwfKNo_vocals00026848.wav,"దాన్ని track చేయడానికి మంది entities లు. లేకపోతే next Uber అనేవాడు ఇంకోటి అన్నాడు, ""అరేయ్ శబ్రీ! ఆ drivers మనకు దొరకట్లేదురా vehicles తో ఉన్నవాళ్ళు. మనం ఏం చేద్దాం అంటే drivers ని వేరేగా onboard చేసుకుందాం"""
wavs/5rTRRIwfKNo_vocals00027110.wav,vehicles ని వేరేగా onboard చేసుకుందాం. దాని తర్వాత డ్రై-- ఒక driver ని ఒక vehicle కి assign చేద్దాం అన్నాడు ఆ మాట.
wavs/5rTRRIwfKNo_vocals00027247.wav,"కానీ మన logic ప్రకారం ఏం చేసాం? మనము ఒక driver onboarding request లో driver ఉంటాడు vehicle ఉంటాడు. మనం link చేసేశాం. కానీ Uber--Uber కొత్త case లో ఏమున్నాయంటే driver వేరే onboarding, vehicle వేరే onboarding. So, the whole point ఏంటి అంటే మీ entities అలా break అయిపోతూ వస్తుంటాయన్నమాట. ఎందుకంటే..."
wavs/5rTRRIwfKNo_vocals00027636.wav,The whole mistake ఎక్కడ జరిగింది అంటే initial flow లో అన్నమాట. అందుకే చాలా సార్లు మనం flow లోని ఎంత time కొక అంత time spend చేయాలి. ఎందుకంటే
wavs/5rTRRIwfKNo_vocals00027827.wav,flow మనం రాసుకున్నాం. ఈ flow అనేది కేవలం ఇప్పటి working మాత్రమే. మనం ఏం చేయాలంటే ప్రతి దగ్గరనూ
wavs/5rTRRIwfKNo_vocals00027985.wav,"Future లో అలా change అవ్వచ్చేమో, future లో ఇలా అవ్వచ్చేమో different different models ఇంకేమున్నాయి అని చెప్పేసి మనం ఒకసారి ఆలోచించాల మాట. ఆలోచించి దీని మొత్తాన్ని మనం generalize చేయాల మాట."
wavs/5rTRRIwfKNo_vocals00028260.wav,"generalize చేసినప్పుడే మీరు correct entities తో వస్తారన్నమాట. For example, trip లో మనం ఏం చెప్పాము? ఒక trip కి ఒక user ఉంటాడు అన్నాం."
wavs/5rTRRIwfKNo_vocals00028467.wav,కానీ మీరు correct గా generalize చేస్తే ఒక trip కి ఎవరుంటారంటే ఒక పాస్-- trip passenger ఉంటాడన్నమాట
wavs/5rTRRIwfKNo_vocals00028629.wav,అలాగా ట్రిప్పులో ఎన్ని passenger పడితే అన్ని passenger ని పెట్టించుకోవచ్చు
wavs/5rTRRIwfKNo_vocals00028722.wav,"సో sudden గా trip user నుంచి నువ్వు ఎలా మారిపోయావు అంటే trip, trip passenger అనే ఒక కొత్త entity create అయిందన్నమాట"
wavs/5rTRRIwfKNo_vocals00028885.wav,"సో, the whole point ఏంటంటే మీరు general గా most of your time మీరు"
wavs/5rTRRIwfKNo_vocals00028994.wav,"Flow దగ్గరే time spend చేయండి. Flow లోని for example నా use case లో అయితే నేను almost ఒక three, four, five days spend చేస్తానన్నమాట. అసలు flow complete గా అర్థం చేసుకోవడానికి. ఎందుకంటే flow ని మనం అర్థం చేసుకుని"
wavs/5rTRRIwfKNo_vocals00029250.wav,దాంతోదాన్ని generalize చేయాలన్నమాట. Generalize చేస్తున్నప్పుడే మనకి entity యొక్క true relations అర్థమవుతాయన్నమాట.
wavs/5rTRRIwfKNo_vocals00029404.wav,"సో, అందుకే business team కరెక్ట్ గా చెప్పినట్టు follow అయిపోకండి. మీ మట్టు మీరు generalize చేయండి. ఎందుకంటే, రేపు పొద్దున business team కొత్త use case తో వచ్చినా కూడానూ మీ entities అనేవి వాటిని support చేయాలనమాట."