แแ แแแแฃแกแแ แฉแแแก แแแแก แแแแแกแขแแแชแแแแฃแ แ แแแแฎแแ, แ แแแแแแช แกแแแแฃแ แจแ แแงแ แฉแแกแแฃแแ แแ แแแแแจแฉแแแแแแก แคแแ แแฃแแแ แแแแจแ, แแ แ-แแ แ แกแแแแแแแแแแแจแ แแแแฎแแแแแก แแแ แแแ แ แแฃแแแแก แจแแแแแ, แกแญแแ แแแแ แแฃ แแ แ แแแแฌแงแแ แแแ แแแแแแแแแ แก SQL แชแแแแ, แแ แแแแแแแแแก แแฃ แแ แ ORM แงแแแแแคแแ แก แแแแแช. แแแแแแฌแงแแแขแ แแแกแฃแฎแแก แแแซแแแแ แชแแขแ แฃแคแ แ แคแแ แแแ, แแแแ แ แฃแแ แแแแ ORM-แกแ แแ SQL-แแ, แแ แซแแ แแแแแแ แแแชแแแ แกแแกแขแแแแขแแแแแฃแแแงแ แแแ แแ แแแ แแแแแแแแแแ, แ แแแแแแแช แแฎแแ แแแแแแ แแแขแแ แแแฃแแแแ แฃแแชแ แแกแ แแ แกแแจแฃแแแ แแแแแก แแแแแแแแ แแแแก แแแแแชแแแแแ, แ แแแแ แแ แแแแ แแกแขแแ แแ แแ แ แ แกแแแงแแ แแ. แชแฎแแแ แแแก. แแแแแแแ, แแ แแฅแแแแ แแแกแแแ แแแ, แแแแ แแ แแก แฉแแแแงแแแแแแ แแแ แแแ แแแแแชแแแแแแแ แแ แแจแแแ แแ แแแ แแแแฃแแ แแงแ แแแแแแแแ แแ แแแแแ แแแ. แแแแแแแ, แกแแแแขแแ แแกแ แแแฎแแ. แแ แ แ แแแแแแแ.
แแแแแแแฃแ แ แแแแแแแแแ แแแแก แแแกแแฎแแแแแ
แแแแกแแแแแก, แ แแ แ แแแแ แแ แแแแฃแแแ แแแแฎแแแก, แแแแแแฌแงแแแขแ แแแแแฌแงแ แแแแแชแแแแแแก แแแซแแแแ แแแแก แจแแกแแฎแแ, แแฃ แ แแแแแแ แแแแแแแแแ แแ แแฆแแก แแกแแคแแแแจแ แแ แ แแแแ แแชแแแแแ แแก แแแแฃแแแชแแ แแ แแแ แแแแแแแแแแแจแ.
แกแฎแแแแแกแฎแแ แฌแงแแ แแแแแก แจแแคแแกแแแแ, แ แแชแฎแแแแ 12-แแแ 30 แแแแแแแแแแ แแแแแแแแแ. แแแแแฌแงแแแขแ แแแฉแแ แแแ
SlashData-แก แแแแแชแแแแแแ, 2018 แฌแแแก แแแแแฎแ แแแแ แขแแแจแ แแกแแคแแแแจแ แแแแฎแแแแแแ 18.9 แแแแแแแ แแแแแแแแแ แ แแงแ, แ แแแแแแแแแ 12.9 แแแแแแแ แแงแ แแ แแคแแกแแแแแแ แแแแแแแแแ แ, แแแฃ แแกแแแ แชแฎแแแ แแแแ แแ แแแ แแแแ แแแแจแ. แแกแแแ, แแแแช แแแแแแแ แแ แแ แแแ แแ แแคแแกแแแแแแ แแแแแแแแแ แแแ, แแ แแแ แแแแแแแแแแ, แแแกแแแแกแแช แแ แแแ แแแแ แแแ แแ แแก แฐแแแ, แแแฃแก แแกแแแ, แแแแช แแแแแแแ แกแฌแแแแแแแ แแ แแคแแกแแแก (แกแฎแแแแแกแฎแแ แกแขแฃแแแแขแแแ แแ แแแแแแแกแฌแแแแแแ). แแแฃ, แแฅ แแ แแก แแแแแจแแแแ แแ แฏแแฃแคแแก แแแแแแ, แ แแแแแแช แแแแแขแแ แแกแแแก - 6 แแแแแแแ แแแแแแแแ. แแแ แแแแ แแแแฎแ แแ, แแก แแแแแ แแแขแแ, แแแแ แ แแแแแแ.
แแแแ แ แกแแฃแ แแ แแแ แฉแแแแแแก แแงแ แแ แแแ แแแแกแขแแแแก แ แแแแแแแแแก แแ แแแก แขแแแแ: 2017 แฌแแแก แแแแ แ แแแแ แขแแแแแ 2018 แฌแแแก แแแแแฎแ แแแแ แขแแแแแแ 14.7-แแแ แแฆแแแจแแฃแ 18.9 แแแแแแแแแแ แแแแแแ แแ, แแแฃ 21 แฌแแแก 2018%-แแ แแแแแแ แแ! แแ แ แแ แแแฎแแแแแแ แแ แแแ แแแแกแขแแแแก แ แแแแแแแแแก แแ แแแก แขแแแแแก แจแแคแแกแแแแก, แแ แแแขแงแแแ, แ แแ แแก แแ แแก แแแแฎแแแแแแ 5% แฌแแแแฌแแแจแ แฌแแแฃแ แ แขแแแแแก แแชแแ แ แแ แแแ. แแ แแฅ แแแแแแแก 20%-แแแ.
แแแ แแ แแแแกแ, SlashData-แก แจแแคแแกแแแแ, 2030 แฌแแแกแแแแก แแแกแแฎแแแแแ 45 แแแแแแแก แแแแฆแฌแแแก. แแแแแแแ แแแแก แแแ แแแแแ, แ แแ แแก แแฃแแแกแฎแแแแก แงแแแแแฌแแแฃแ แแ 8%-แแ แแแแแ แแแข แแ แแแก แแ แแ แ 20%-แก, แแแแ แแ แแกแแแ แแแฃแแแแแแแ แแแ แแฅแขแแ แแแแแ แแแขแแ แแแขแแก แจแแฆแฌแแแแแแแแก แแแแแแแแกแฌแแแแแแ (แแแแแแแ แแแแฎแแแแแแ 57% แแกแแคแแแแจแ).
แแแแแแแ, แแแแ แ แแ แแแ แแแแกแขแ แแฅแแแแ, แ แแแแ แช แแ แฃแแแ แจแแฎแแแ แแแแก, แ แแแแแ แแแแฎแแแแ แแแ แแแแ. แกแฎแแแแ แจแแ แแก, แแแแฎแแแแแก แจแแกแแฎแแ.
แ แ แแ แแก แแแแฎแแแแ?
แแแแฎแแแแแก แจแแกแแคแแกแแแแแ แแ แแแแแแแงแแแ HackerRank แแแแแชแแแแแ
แแ แแแ แแแแ แแแแก แแแแแแก แแแแแกแแแ แแกแแ, แงแแแแแแ แแแแ แแแแฎแแแแแ JavaScript, Python แแ Java แแแแฅแแแก แงแแแแ แแแแฃแกแขแ แแแจแ, แแแ แแ แแแแแแฃแขแแ แฃแแ แขแแฅแแแแแกแ. แแ แฃแแแแแกแแแแแจแ แงแแแแแแ แแแแ แแแแฎแแแแแ C/C++-แแ, แ แแช แแแกแแแแแแ, แขแแฅแแแแแก แแ แแแฅแขแแแก แฏแแ แแแแแ แแฅแแ แแแแฎแแแแแแ แ แแกแฃแ แกแแก แแแขแแแกแแแแแแแ แแ แจแแกแแแแแแกแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แจแแกแ แฃแแแแแแ.
แฉแแ แฉแแแแแก แแแแแกแแแ แแกแแ, AngularJS, Node.js แแ React แงแแแแแแ แแแแ แแแแฎแแแแแ แแ แแแ แแฅแแ แงแแแแแแ แแแแ แฃแคแกแแ แฃแแ แแแฌแแแแแแกแ แแ แแแแฎแแแแแก แจแแ แแก, แ แแช, แ แแแแ แช แฉแแแก, แแแฎแกแแแแ แแ แกแแฉแฅแแ แแ, แ แแแแแแแช แแชแแแแแ JavaScript แแแแกแแกแขแแแ, แ แแแแแ แแแแแแแแแ, ExpressJS-แแกแแแแก. , แแแฌแแแแแ แฃแแแ แแญแแ แแแแก แแแแฎแแแแแก.
แแแแแแขแแแชแแแแแก แแฃแแฎแแ, แแแแกแแฅแแแแแแแ แแแ แแแ แ แแแจแ แแแแแแแแขแแแแกแแแ แแแแแ แแ แแแแแแแก แแแแแญแ แแก แฃแแแ แแแก. แแแแกแแฅแแแแแแแ แแแแฎแแแแแแ 95% แแฆแแแจแแแแก แแ แฃแแแ แแแก, แ แแแแ แช แแแแจแแแแแแแแแก. แแแแ แ แแแแแแแแ แแ แแแ แแแแ แแแแก แแแแก แชแแแแ 56%-แแ. แกแฎแแแแ แจแแ แแก, แกแแแ แแแ แแ แแ แแก แฎแแแ แแแแแ แแแแแแแก, แแแแแชแแแแ แกแขแ แฃแฅแขแฃแ แแแแก แแ แกแฎแแ แแแแแแฃแขแแ แฃแแ แแแชแแแแ แแแแแแก แคแฃแแแแแแแขแฃแ แชแแแแแกแแแ, แแ แแก แแ แแงแ แแแแฎแแแ แจแ, แแ แแแแแแแแฃแ แ แชแแแแ แแฆแแ แแ แแก แกแแญแแ แ แคแแ แแ แแแกแจแขแแแแ.
แแแแแชแแแแ แแแแแก แแแแแแแ แกแญแแ แแแแ 23.2 แแแแแแแแแ แฃแแชแ แแกแ แแแแแแแแแแแก 100%-แก แแ 18.8 แแแแแแแแแ แแแขแ แแแแแแแแแแแก 1000%-แก. แแแแฎ, แ แแแแ แช แฉแแแก, แแก แแฎแแแ ORM-แกแ แแ SQL-แก! แแแแแแฃแ แ, IMHO, แแฎแกแแ แแ แแก แแก, แ แแ แแแ แแแแแแแแแแจแ แแ แแก DBA-แแก แ แแแ, แ แแแแแแช แแแกแฃแฎแแกแแแแแแแแ แแ แแกแแแฅแขแแ แแ, แจแแกแแแแแแกแแ, แจแแกแแซแแแแแแแ แแแแแแแแแ แแแแกแแแแก แแแแฎแแแแแแแก แจแแ แแแแแแ แแ แฃแคแ แ แกแฌแ แแคแแ แแแฅแแ แแแแแ. แแแแ แแ แกแแกแขแแแแก แแแแแแแแก แจแแแแฎแแแแแจแ แแแ แแฅแแแแ: 37.0% แแแขแแ แแแแจแ, 44.1% แแแแแแจแ. แ แแแแ แช แฉแแแก, แแแแแแก แฃแแแ แฐแงแแแแแ แแแแแแแแแฃแแ แแ แฅแแขแแฅแขแแ แแแ, แแแแ แแ แจแแกแแซแแแ แแแ แฃแแ แแแแ แแแ แแแคแแ แแ แแแแแ แแ แแแฃแแ แกแแกแขแแแแแแก แ แแแแแแแแ. แแ แแแแแ แคแฃแแแแแแแขแฃแ แ แแแแแ แแแแแแ แแ แแแแแชแแแแ แกแขแ แฃแฅแขแฃแ แแแ แฉแแแแแฃแแแ แกแแกแขแแแแก แแแแแแแจแ, แจแแแแแ แแก แชแแขแ แฃแคแ แ แแแแแแ แฎแแแแ.
แแชแแ แ แแแแแแแแแแก แกแฃแ แฃแคแ แ แแแแแแแแ แกแญแแ แแแแแ Framework Proficiency-แแก แแแแแแฆแแแจแแฃแแ แกแแกแขแแแแก แแแแแแแ, แกแแแแแแแช แจแแแแแซแแแ แแแแแแแขแแแแ แแแแแขแแแก แแแกแแแแ, แ แแ แกแขแแ แขแแแแแแกแแแแก แแแแจแแแแแแแแแแ, แ แแช แจแแแซแแแแ แกแฌแ แแคแแ แแแแแฃแจแแแ แ แแฆแแชแแแแ แแ แแแฅแแแแ แแ แแแฃแฅแขแ แแ แฎแแแ แแฅแแแแ แฎแแแ.
แ แแก แกแฌแแแแแแแ แกแขแฃแแแแขแแแ?
แแฅ แแ แแแงแ แแแแแแแ แกแฎแแแก แแแแแชแแแแแก
แแแแจแแแแแแแแแแ แแแแแแแแแแกแฌแแแแ, แ แแ แแแฃแฎแแแแแแ แแแแกแ, แ แแ แแ แแแ แแแแ แแแ แแแ แแฃ แแ แคแแ แแแ แแกแฌแแแแแแ แฃแแแแแ แกแแขแแขแแแจแ (แแแฃแแแกแฎแแแ แแแแแแฃแขแแ แฃแแ แแแชแแแแ แแแแก แกแแแชแแแแแแแแก), แแแแแแแแฎแฃแแแ แแแฎแแแแ แแ แแแขแแ แแแแแชแฎแแแ, แ แแ แแกแแแ แแกแแแ แแแแแแแแแแแแแแ แแ แแแ แแแแแแแแฃแแแ.
แแแแแแแแ แแแ แกแขแฃแแแแขแแแก แฃแ แฉแแแแแแ แแกแฌแแแแแ YouTube-แแแ, แฎแแแ แฃแคแ แแกแ แแแแแแแแแ แแแ แแแแแ แแแแแ แแแแแแแแแแแก แแ แฌแแแแแแก. แแ แแแ แแแแแแแ แแฅแขแแฃแ แแ แแงแแแแแก StackOverflow-แก. แแแแก แแแแแฌแแ แแ แคแแฅแขแก, แ แแ แแแแแ แแ แแก แแแชแแแแ แแแแแ แแ แฎแ Z แแแแแแกแแแแก, แฎแแแ Y แแแแแแก แฌแแ แแแแแแแแแแแแ แฏแแ แแแแแ แแแแแแ แแแแก แแแ แแจแ แแแแฅแแจแ แแ แแแ.
แแกแแแ แแกแฌแแแแแแ แ แ แแ แแก แแแแกแแฅแแแแแแแแก แแแแฎแแแแ: JavaScript, Java, Python. แแกแแแ แแแฃแแแแแแแ, แ แแ แแแ แแชแแแ C/C++, แแแแ แแ แแก แแแแแ แแแแขแแ แฎแแแแ, แ แแ แแก แแแแแ แแแแแแงแแแแแ แฃแแแแแ แกแแขแแขแแแจแ แกแฌแแแแแแแกแแแแก. แแกแแแ แแกแฌแแแแแแ JS แฉแแ แฉแแแแก, แแแแ แแ แแแแฎแแแแ แแแแจแแแแแแแแแ แแฆแแแแขแแแ แแแฌแแแแแแก, แแแแขแแ, แ แแแแ แช แฉแแแก, แแกแแแ แแฅแขแแฃแ แแ แกแฌแแแแแแแ แแแ แแแแ แกแแแฃแจแแแก แแแแแแก แจแแแแแ.
แแแแแแแ, แ แแแแ แช แแแกแแแแแแแแ แแงแ, แแกแฌแแแแแแ แแแแก, แ แแช แแแแฎแแแแแแแ.
แกแขแฃแแแแขแแแ แแแแแ แแ แแคแแกแแฃแ แแ แแแก แแแ แแแแ แกแแแฃแจแแแแแ, แกแแแฃแจแแ แแ แชแฎแแแ แแแแก แแแแแแกแ แแแแ แ แแแแแแแแ (แแแแแแ แ แฅแแแงแแแแจแ แแแ แแแ แ แแแจแ), แฎแแแ แกแแแแขแแ แแกแ แแแแชแแแแแ แแแกแแแแแ.
แแแแแแแแแ แแก แแแกแแฎแแแแแแก แแแแแแแแ แแ แแแ แแแแ แแแแก แแแแแแกแ แแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แขแแแแแแก แแแฎแแแแแ
แแแ แแแแแแแชแแแแ แแแ แแแ แแแแแแแแ, แแแแฎแแแแแแ 16.9 แแแแแแแ แแแแแแแแแ แแแแ. แแก แแ แแก แแกแแ SlashData. แจแแแแแแแ Backend Services (13.6 แแแแแแแ), แแแแแแฃแ แ แแแแแแแชแแแแ (13.1 แแแแแแแ) แแ Desktop (12.3 แแแแแแแ). AR/VR แแ IoT แกแแฅแขแแ แแแ แแแแแแแแ แแแแฃแแแ แแแแก แแซแแแก, AI/ML/Data Science แแแแจแแแแแแแแแ แแแแแแ แแ แแแแ แแ แ แฌแแแก แแแแแแแแแแแจแ.
Javascript แงแแแแแแ แกแฌแ แแคแแ แแแ แแแแ; แแแกแ แกแแแแแแแแแแ แฃแแแ แงแแแแแแ แแแแแ, แแฎแแแแ 2018 แฌแแแก แแแ แแแแ 2.5 แแแแแแแแ. แแกแแแ แแ แชแแแแแแแ แแแกแจแ แฉแแฌแแ แแ IoT แแ ML แกแแฅแขแแ แแแจแ.
แแแแแแ 2018 แฌแแแก 2.2 แแแแแแแแ แแแแแแ แแ ML-แแก แแแแ แแ แแแแฃแแแ แแแแก แแแแ, แกแแแแช แแก แขแ แแแแชแแฃแแแ แซแแแแ แแ, แแกแแแ แกแฌแแแแแก แกแแแแ แขแแแแกแ แแ แแแแก แแแฎแแ แฎแแแฃแแแแแก แแแแ.
Java, C/C++ แแ C# แฃแคแ แ แแแแ แขแแแแแ แแแ แแแแ, แแแแ แ แแแแแแแ แแแแแแแแแ แแแแก แแแแฃแแแชแแ. แแกแแแ แแฎแแ แแจแแแแแแ แแ แแแ แแ แแแ แแแแ แแแแก แแแ, แ แแแแแแแช แแแแแแแแแแ แแ แฉแแแแ แแแกแแฌแงแแแแ. แแแแแแแแแ แแแแ แแแแฎแแแแ แแฅ แแแข-แแแแแแแแ แแแแแแแแกแแแฃแแแ แแแฌแแแแแแกแแแ. แแ แแคแแฅแ แแ, แ แแ แฏแแแ แแแแแ แฃแคแ แ แแแแ แแแแแ แแแแแแ, แ แแ แแ แ Android.
PHP แแ แแก แแแแ แ แงแแแแแแ แแแแฃแแแ แฃแแ แแแ แแแแแแแชแแแก แแ แแแ แแแแ แแแแก แแแ แแ แแก แแกแแแ แแแแจแแแแแแแแแ แแแ แแแแ (32 แฌแแแก 2018%-แแ). แแแกแ แกแแแแแแแแแแ แจแแคแแกแแแฃแแแ 5.9 แแแแแแ แแแแแแแแแ แแ. PHP-แแก แแแแแ แแแแแฃแแ แ แแแฃแขแแชแแแก แแแฃแฎแแแแแแ, แแแกแ แกแฌแแแแ แกแแแแแแ แแแ แขแแแแ แแ แคแแ แแแ แแแแแแงแแแแแ.
แ แแแแ แกแฌแแแแแแแ แแฆแแแแแแแแ แแฎแแแแแแ แแ แแแแแแแแขแแแ แฌแแแ แแแแแแแแแ แจแแแแ แแแแ?
แแกแแ HackerRank แแแแแชแแแแแ. แแกแแแ, แแแแช แแฎแแ 38-แแแ 53 แฌแแแแแ แแ แแแ, แแแ แแแ แแ แแแฅแขแแแแ แฉแแแแแแแแแ แแแแแจแแแก.
แกแฎแแแแ แจแแ แแก, แแแแแกแขแฃแ แแ, แ แแ แฉแแแ แแแ แแแแ แแแข-แแแแแแแแ แกแแแฃแจแแ แแ แแแฅแขแ แแงแ โtic-tac-toeโ แแแแแแแ แฎแฃแแแแแ แจแแฃแแฆแฃแแแแ แแแแแ, แแแแ แ แแงแ แแแแแจแ 15. แแก แงแแแแแคแแ แ แแแแฌแแ แ.
แแแแแแแแ แแแ แแแแฌแงแแแ แแ แแแ แแแแกแขแแแ (21 แฌแแแแแ) แแแ แแแ แแ แแแฅแขแแ แฌแแ แแ แแแแแฃแแแขแแ แแแกแ แแ แแแแแแแ แแแแก.
X แแแแแแก แฌแแ แแแแแแแแแแแแก แจแแ แแก, แแแแฅแแแก แแแฎแแแแ แแ แแแแฌแงแ แแแแแก แฌแแ แ 16 แฌแแแแแ, แแแแ แ แแแแก แแแแแแแแ 5-แแแ 10 แฌแแแแแ (แซแแ แแแแแแ แแกแแแ, แแแแช แแฎแแ แแ แแแ 35-แแแ 45 แฌแแแแแ). แแแข-แแแแแแแแ แแแกแแแแแแ แ แแขแแแแช: แแแคแแ แแแชแแแก แฌแงแแ แ แชแแขแ แแงแ แแ แแ แแแ แแแแกแขแ แ แแ แแแฎแแ, แซแแแแแ แฃแแแ แแแแแแแแก, แแ แแแกแแช แแก แซแแแแแ แกแฃแ แแ, แแแ แ แแแแฌแงแ แแ แแแ แแแแ แแแ. แแแกแแช แแก แแกแ แแ แกแฃแ แแ, แแแแ แแแแแแแแแ, แแฎแแ แกแฎแแ แแ แแคแแกแแ แแฅแแก, แแแแขแแ แกแแชแแแแแแแแจแ แกแฃแ แแแ แแฃแกแขแแ แแกแแแแ.
แแฆแแแแแแแแ แแฎแแแแแแ แแ แแแแแแแแขแแแ แจแแแแฎแแแแแแแก แแฎแแแแ 20% แแฌแงแแแแ แแ แแแ แแแแ แแแแก 16 แฌแแแแแ, แฃแแแขแแกแแแ แกแแแฆแแช 16-แแแ 20 แฌแแแแแ. แแแแ แแ แแแแแแแก แแกแแแ แแแแแแแ แกแฌแแแแ; แแฎแแ แแก แแแแ แแ แฃแคแ แ แฎแแแแแกแแฌแแแแแแ.
แแแกแแแแแแ
แแ แฏแแ แแแแแ แแแ แแแแแแ แแแแแ แแขแฃแแ แแแกแฃแฎแ แแแแฎแแแแ, แกแญแแ แแแแ แแฃ แแ แ แแแแฌแงแแ แแแ แแแแแแแแแ แก SQL แแฆแแก, แแแแ แแ แแ แแแแแแแกแฌแแ แ แฉแแแ แแแแ แแ แแแ แแแแกแขแแแแก แแแแแแแแ แแแ แแแแฃแแแชแแแก แจแแกแแฎแแ.
แแแแแแแแแ แแแแก แจแแแแแแ แแแแแ แฃแแ แแแ แฎแแแฎแแ, แ แแฆแแช แแฎแ แแ แแกแแแ แฌแแแแแแก แฐแแแแแแ, แกแแแแแแ แแ แแแแแแแ แแฎแแแแ แแแแคแฃแญแ แแกแแแ. แแกแแแ แแแแแงแแคแแแแแแ แแแแกแแฅแแแแแแแแก แแแแ แจแแฅแแแแ แแแแฎแแแแแก. แแ แแคแแกแแแจแ แจแแกแแแแก แแแ แแแ แ แฃแคแ แ แแแแแแ แแแฎแแ แฃแคแ แ แแแกแแฎแแ แฎแแแแแ แฎแแแกแแฌแงแแแแแกแ แแ แฉแแ แฉแแแแแก แแแแ, แ แแช แกแแจแฃแแแแแแก แแแซแแแแ แกแฌแ แแคแแ แแแแฆแฌแแแ แจแแแแแแแก. แแฎแแ แฃแคแ แ แแแขแ แแแแแแแแ แฎแแแแ แแ แแแ แแแแกแขแ; แชแแคแ แฃแแ แแแแแ (Z แแแแแ) แแแแแแแแแแแ แชแฎแแแ แแแก แขแแฅแแแแแแแแจแ; แแแแแแแก แแก แฉแแแฃแแแแ แแแ แแ แแคแแกแแแ, แกแฎแแแแแ แฃแแ แแกแ.
แแกแแแ, แแแแช แแชแแแ, แ แแ L1 แฅแแจแแก แจแแงแแแแแแ แแ แแก ~4 แชแแแแ, แแ แ แแ แฃแแฏแแแแกแแ แแ แแแฎแแแก แฅแแจแแก แฎแแแแแแก แแแแแแขแแ แแแคแฃแญแแแ, แกแฃแ แฃแคแ แ แแชแแ แ แฎแแแแ แแแแฃแแแชแแแก แแแแแแแ แแแแแก แแ แแชแแแขแฃแแแ. แแฃแแชแ, แแแ แแ แฃแแแ แแแแ แแแฃแแแ แกแแแกแแฎแฃแ แแก แจแแแแแแ; แแแแแก แแ แแแแแก, แแแฆแแชแแ แฃแแแ แแแฌแแ แแก แแแแแแ แแแแแก แ แแฆแแชแแแแ, แกแแแแช แฏแแ แแแแแ แกแแญแแ แแ. แแกแแแ, แแแกแแช แแฅแแก แฆแ แแ แคแฃแแแแแแแขแฃแ แ แชแแแแ แกแแกแขแแแแก แแแแแแแจแ แแ แจแแแซแแแ แแแ แกแแกแฎแแแแ แแ แแฅแขแแแฃแ แแ แซแแแแแจแ แแ แแ แแแฐแงแแแแ แแฎแแแแ แขแแแ แแแก แแฃแแขแก, แแ แฃแแแ แแแแ แแแฃแแแ. แแแแก แแแแ, แ แแ แแฃแแแแแจแ แแฅแแแแ แแแขแ แแแแแแแแ, แ แแแแแแกแแช แจแแฃแซแแแแ โแฃแแ แแแแ แแแฌแแ แแ แแแแโ แแ โแฃแแ แแแแโ แแแแแแงแแแแ แคแ แแแแแแแแแ, แแ แแแแกแแแแแก, แ แแ โแแแชแแแแแแแแ แฃแแแแแแ แแแขแแ แแแฃแแ แฌแแแแแก แแขแแแฏแแแแ แขแแแแแแโ (แ) แแแ แแแแแแแแกแแแ แแแกแญแแ แแแแแ แกแฌแแ แแ แแกแแ แแแแแแแแแแแแ. .
แ แแแแ แฃแแแ แแแ แแแแแแแแ แแแแแแแก แกแแกแฃแ แแแแแก แแแขแแแแ แแแแแ แกแแแแแแแแฃแแแแ (แแแแก แแแแแแแกแขแฃแ แแแแแ แแแแแฅแขแฃแ แ แแแแแชแแแแแ แแ แแแฅแแก, แแฎแแแแ แแ แแฅแขแแแฃแแ แแแแแแ แแแแ). แแ แแแ แแแแกแขแแแแก แ แแชแฎแแ แแแ แแแแ แแ แแแ แงแแแแ แฃแแแ แแแแแ แแแ แจแแแแแแก แแแกแแฆแฌแแแแ, แแแ แแแแแ แ แแฃ แแ แแแ แแแแขแ แแแแก แแแแ แแ แกแฌแแ แแ แแแแกแแแแก แแ แแก แกแแญแแ แ แ แแแแ แฃแแแ แแแ.
โEnter ITโ แแแฉแแแแแแ, แ แแ แแแแแแแแ แแแ แ แแแแแแแแฃแ แ แแแแแแแ, แขแแแแฃแ แ แแ แแแแแแแแแกแแแแก, แกแแแแช แแ แแแ แแแแกแขแแก แจแแแแกแแแแแ แแแแจแแแแแแแแแ แแแแกแฎแแแแแแแ แจแแแแ แแแแแ โแแ แ-ITโ แกแแแชแแแแแกแขแแก แจแแแแกแแแแแกแแแ. แแแแกแแจแ, แกแแแแช แแ แแชแฎแแแ แแ, แแก แแแแแแแ แแแกแแแ แแแ แแแซแ แแแแแ, แงแแแแแแฆแ แแฎแแแแ แ แแแแแแแแก แแฎแแแ แแฃแ แกแแแแกแแแแก, แแฃ แ แแแแ แฃแแแ แแแฎแแแ แกแแกแฃแ แแแ IT-แจแ, แแ แแแกแฃแคแแแแแแแก แแแแแแแแแแ แแแแแแ แแกแแฎแแแก แแ แแแ แแแแกแขแแแก แแแกแแฏแแ โแแแกแแแ แแ แกแฃแ แแแแ แแแชแแแฃแแ แแแแ? แแก แแแจแแแแก, แ แแ แแฅแแแ แแแฅแแ แกแแจแฃแแแแแ แแ แแแแแแแแ แแฅแแแแ แแแแ, แฉแแแ แงแแแแแคแแ แก แแแแแแแแแแ แแฅแแแแแแแก.โ แ แแแแ แช แฉแแแก, แแแแแ แฎแแแแ แแแแแแ แ แแแแแแแจแ. แแ แช แแ แแแฅแแก แแแแก แแแแแแแกแขแฃแ แแแแแ แแแแแชแแแแแ.
แแแแแแแ, แฉแแแ แแแ แแ, แแ แแแ แแแแกแขแแแแก แแแกแแฎแแแแแแก แแ แแคแแ แ แแแฃแฅแ แแแ. แแแ แ แแ แแฅแแก แแแแแ แแแก แแแแก แจแแกแแฎแแ, แ แแ แแฆแแก แแแแแแแแแแแจแ แแแ แแแแแแ แแแแแแแ แแ แแแ แแแแกแขแแแก แแ แ แแ แแแแแแแแขแแแแ แฎแจแแ แแ โแแ แแคแแ แ แแชแแแโ. แแกแแแ แแกแแแแแ แญแแแแแแแแ แแ แฃแแแ แแแแแแ แแ แแแ, แจแแกแแซแแแ แฃแคแ แ แญแแแแแแแแ แแ แฃแแแ แแแแแแแช, แแแแ แ โแแแแแแแแ แแ แแแ แแแแกแขแแแโ; แแกแแแ แฃแแ แแแแ แแซแแแแ แชแแแแแก, แ แแกแแช แแแแแแ แแแแแฎแแแก แกแฌแ แแคแแ แแแแ แแ แแแแแ แ แแ แแแแแแแแแแแ แแแแแแแแแ แแแแก, แ แแช แฏแแ แแ แกแญแแ แแแแแแแ แแ แแ แแแแขแแแก แกแแ แแแแแแก. แแฎแแ. แแกแแแ แแกแฌแแแแแแ แ แแชแ แแแกแญแแ แแแแแ, แ แแแแแ แกแฌแแแแ แแแแแช แกแฃแ แ. แแแแแ, แงแแแแแก แแ แแฅแแแแ แแแแก แฃแแแ แ, แแแแ แแ แงแแแแแก แแ แแแกแญแแ แแแแ แแก; แฃแแฎแแแแก แแแแแแแแจแ, แแแแแ แ แแแแแแแ แแแแฆแแแก แแแแแแแแแแก, แ แแแแแแกแแช แจแแฃแซแแแแ แกแฌแ แแคแแ แจแแแแแแแแ แกแฎแแ แแแแแชแฎแแแแก แแแแชแแคแชแแ แแแ แแแแฃแแ แฉแแ แฉแแก แแแแแงแแแแแแ.
แแแแแแแแฎแแแจแ แแแแแฌแแแแแแ แจแแฃแซแแแแ แแฎแแแแ แแแ แแแแกแขแ แแ แแแฃแ แแแแฎแแแ แแแแแแก.
แแแแแฎแแแก แแฃ แแ แ แแแ แกแแ แแแแ แแ แแแขแแ แแแฃแแแ SQL แชแแแแแก?
-
แแแแฎ, แแแแฎแแ แแแแขแแ, แ แแ แกแแแฃแจแแแกแแแแก แแญแแ แแแแ
-
แแแแฎ, แแแแแแแ, แแแฃแฎแแแแแแ แแแแกแ, แ แแ แแก แแจแแแแแแ แแ แแก แกแแญแแ แ แกแแแกแแฎแฃแ แจแ.
-
แแ แ, แแ แแ แแญแแ แแแแ, แฉแแแ แแแแฅแแก NoSQL
-
แแ แ, แแ แแแแก แแ แแแแฎแแ, ORM แงแแแแแคแแ แก แแแแแแแแแก
แแแกแชแ แฎแแ 320 แแแแฎแแแ แแแแแแ. 230-แแ แแแแฎแแแ แแแแแแ แแแแ แจแแแแแแ.
แฌแงแแ แ: www.habr.com