แกแแแแแแแแแแแแแแ แ แแแแขแแแแก แแแแแแแแแแ แแ แแแแแคแแ แแแแแแแก แ แแ แฃแงแฃแ แแแ, แแแฎแแ แฃแแ แฎแแ แ, แ แแ แแแแจแแแแก แแฅแแ แฌแแแแแ แฃแแแ แแ แกแแแจแแแแแแ แแแแแแแฅแขแแ, แแแ แแ แแแฃแฅแขแแแแ แแ แ แแ แแ แแแ แแแแ แแแแก แกแแคแฃแซแแแแแจแ โแจแแกแแแแกโ แแแ แ แกแแแแแแ แแแแแ แแแแชแ (แแแแจแแแก แแแฆแแแแ. ). แคแแ แแแ แแ แแก แแแแ แชแแแแแฃแแ แขแแแแแแชแแ แฏแแ แแแแฃแแฃแ แ แแแแแแก แแ แแแ แแแแ แแแแก แแแแแ แแแแกแ แแ แจแแแแแ แฃแคแ แ แแแฌแแแแแ แแแแแแ แแแแแกแแแแก. แแแแ แแ แแก แกแแขแฃแแชแแ แงแแแแแแแแก แแกแ แแ แแงแ.
2009-2010 แฌแฌ. แ แฃแกแแแแ Arduino-แกแ แแ Scratch-แแก แแแกแแฃแ แแ แแแชแแแแ แแแแฌแงแ. แฎแแแแแกแแฌแแแแแ แแแแฅแขแ แแแแแ แแ แแ แแแ แแแแ แแแ แแฌแงแแแก แ แแแแ แช แแแแฃแแแแกแขแแแแก, แแกแ แแแกแฌแแแแแแแแแแก แแแแแแแก แแแแงแ แแแแก แแ แแ แงแแแแแคแ แแก แแแแแแจแแ แแแแก แแแแ แฃแแแ แแแฉแแฆแแ (แแ แแแฌแแแแแ แแ แแแแฎแแ แชแแแแแ) แแแแแแแฃแ แกแแแแคแแ แแแชแแ แกแแแ แชแแจแ.
แกแแแแแแแแแแจแ, Scratch-แก, แแ แแ แแก แแแแแจแแแแฃแ แแแ แกแแแจแ 1.4, แฃแแแ แฐแฅแแแแ แแแ แ แแแแ แแขแฃแ แแก แแฎแแ แแแญแแ แ. แแแ แแแแชแแแแ แแฎแแ แแแญแแ แแก Lego WeDo-แกแแแแก (แกแแแแขแแแแแแแ แแแแแแแ) แแ .
แแแแ แแ แแ แแแแแแแ Arduino แแ แแแกแแ แแแคแฃแซแแแแฃแแ แ แแแแขแแแ, แกแแกแฃแ แแแแแ แกแแแแแแกแ แแแ แกแแแแ แแฃแจแแแแ. แแแแแแ แแฃแแแ, แแ แ-แแ แแแ แแแแแแแแแ Arduino-แก แแแแแแแ แแ แแแแ แแแแ, แแฃ แ แแแแ แฃแแแ แแแแแแแจแแ แแ แแแแขแคแแ แแแแ แแ แแแแแแฅแแแงแแ แกแฅแแแแแ (แแฃแแชแ แงแแแแ แแแแแแแ แแ แแงแ โแแแแแ แแแฃแแโ) แแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแ แกแแแแแแแแแแ แแแ แฌแแแแแแกแแแแก (แแแแ แแ แกแแแฌแฃแฎแแ แแ, แแ แช แแแแแแกแฃแ แแ. ). แแ แแ แแแฅแขแแก แกแแคแฃแซแแแแแ, ScratchDuino แแแแแแแ 2010 แฌแแแก (แแ แแ แแก แแ แแ แฉแแแ แแแฃแฆแแ แแแฃแจแแแแแแ แแแแแแแแ Linux Center-แจแ).
โแจแแกแแชแแแแแ แแแ แขแ แแฏแแกโ แแแแชแแคแชแแ (แ แแแแ แช Micro:bit?), แแแแแแขแฃแ แ แกแแแแแ แแแ แ แแแแขแแก แแแแแแแแแขแแแแกแแแแก แแ Scratch-แแก แฉแแจแแแแแฃแแ แกแแแกแแ แแก แแแแฃแจแแแแแแกแ แแ แซแ แแแแก แแแแขแ แแแแก แจแแกแแซแแแแแแแแแแก แแแแแงแแแแแ.
แ แแแแขแ แแแแแแแแ แแแแแ แแแแแฃแแแแแแ แแงแ แแแแแกแแแ แแแแกแแแแแแ:
2011 แฌแแแก แแแแขแคแแ แแ แแแแแแแแ แแ (แแแก แจแแแแแ แ แแช แแ แแ แฉแแแแ แแแฃแฆแแแ แแแแขแแแแ แแ แแแฅแขแ 2013 แฌแแแก) แแก แแแแแแแ แชแฎแแแ แแแก แแ แแแแแ แแแแ แกแแฎแแแฌแแแแแแ ROBBO.
แจแแแซแแแแ แแแแแแ แแฅแแแก, แ แแ แแกแแแแกแ แแ แแแฅแขแแแ แแงแ. แแแแฎ, S4A แแ แแแฅแขแแ แแแแฌแงแ แแแแแแแแ แแแ แแแแฎแแแแแแ แแแแแ แแ แแก, แแแแ แแ แแกแแแ แแแแแแ แแกแแฎแแแแแแ แแฃแกแขแแ Arduino-แก แกแขแแแจแ แแแแ แแแ แแแแแแก (แแแกแ แชแแคแ แฃแแ แแ แแแแแแแฃแ แ แแแแแแแแแแแแ) แจแแชแแแแแ Scratch-แแแแ, แฎแแแ แฉแแแ แแแแแแแแ แแแ แจแแแซแแแแ แแฃแจแแแแแแก "แแแแแแแก" แแแ แกแแแ (แแฃแแชแ แฉแแแ แแกแแแ แจแแแชแแแแแ แแแแแแแแก แฉแแแแแแ แกแแแชแแแแฃแ แแ แกแแแกแแ แแแแกแแแแก 1-แแแ 4-แแแ).
แจแแแแแ แแแแแฉแแแ Scratch 2.0 แแ แแแกแแแ แแ แแแ แแแแแฉแแแ แแแแแแแขแแแ แ แแแแ แช Arduino-แกแแแแก, แแกแแแ แแแแฃแแแ แฃแแ แ แแแแขแแแแกแแแแก, แฎแแแ Scratch 3.0 out of box แแฎแแ แก แฃแญแแ แก แ แแแแขแฃแ แแแแขแคแแ แแแแแก แแแ แ แแแแแแแแแก.
แแแแแแ แแแฃแแแ. แแฃ แแแแแแฎแแแแแ แแแแฃแแแ แฃแ แ แแแแขแแแก, แ แแแแ แแชแแ MBot (แ แแแแแแแช, แกแฎแแแแ แจแแ แแก, แแแแแแแแ แแแแแ แแกแแแ แแงแแแแแแแแ แจแแชแแแแ Scratch-แก), แแกแแแ แแแแ แแแ แแแแแฃแแแ แแแแแแก แแแแแ, แแแแ แแ แแก แแ แแ แแก Scratch, แแ แแแแ แจแแชแแแแแ Blockly Google-แแกแแแ. แแ แแแชแ, แแฅแแแแ แแฃ แแ แ แฉแแแแ แแแแแแแ แแแก แแแแแแแแ แแแแแ, แแแแ แแ แแแแแแแแแแแแแ แจแแแแซแแแ แแแฅแแ, แ แแ แ แแแแกแแช 2013 แฌแแแก แแแแแแแจแ Blockly-แแก แแแแแแแแแ แแแก แแแฉแแแแแ Scratchduino แแแแขแคแแ แแ, แแฅ แ แแแแขแแแแก แกแฃแแ แฏแแ แแ แแงแ.
แแฎแแ Blockly แแแแแคแแแแชแแแแ แฅแแแแก แแ แแแแแ แ แแแแขแฃแแ แแแแกแขแ แฃแฅแขแแ แแกแ แแ แกแแแแแแแแแแแแแแ แ แแแแขแแก แกแแคแฃแซแแแแก, แแ แแก แแแแแ แแ แแ แแแแแแแ, แ แแแแแ แแฎแแแฎแแ แแแแแฉแแแ (แแ แแกแแแ แแแแแฌแงแแแแก แแแแชแ) แฃแแแ แแแ แแ แแแฅแขแ, แ แแแแ แช แ แฃแกแแแจแ, แแกแแแ แแกแแคแแแแจแ. แแแแ แแ แ แฃแกแแแแก แคแแแแ แแชแแแจแ แฉแแแ แแแ แแแแ แแแงแแแแ Scratch-แแก แแแแฎแแ แชแแแแแแแจแ แแ แแแแแกแแแ "แแแแแ แแกแแแ แแแแจแ" :)
แ แ แแแฎแแ 2013 แฌแแแก แจแแแแแ? 2014 แฌแแแก แแ แแ แฉแแแแ แแแฃแฆแแแ แแแแแแ แกแแ แฉแแแแ แแ แแแฅแขแ PROSTOROBOT (aka SIMPLEROBOT) แแ แฉแแแแแแ แกแแแแแแแ แแแแแจแแแแก แแแแแแแแ แแแแจแ. แแแแ แแ แกแแ แแฉแ แแ แแแแแแจแแแแก.
แฉแแแ แแแแฅแแก แกแแแแขแแ แแกแ แแแแแแแแ แแแ แ แแแแขแแแแก แแแแแแแ แแแแจแ Scratch-แจแ แแ แแแก แจแแแแแแแแแ Snap-แจแ!
PDF แคแแแแ แแฆแฌแแ แแแแแแ แจแแแแซแแแแ แฉแแแแขแแแ แแแ แแ แแแแแแงแแแแ แแแแแกแฃแคแแแ แแ แแแกแ แฃแแแแฃแแ แแ แแแฅแขแแแ . แงแแแแแคแแ แ แแฃแจแแแแก Scratch-แแก แแ-3 แแแ แกแแแจแ.
แฉแแแ แแกแแแ แแแแฃแแ แฃแแแแ แ แแแแขแแแแก แแ แแแ แแแแ แแแแก Scratch-แจแ แฉแแแแก แแฎแแ แกแแแแแแแ แกแแแแแแแแแแแแแแ แแแแแจแจแ โแแแแแแแแแก แแ แซแแแโ. แแแ แขแแก แแแแ แแแ แแแแขแแแแกโ แแ แแแฎแแ แฃแแ แแแฅแแแแแ แแฃ .
แ แแชแ แ แแฆแแชแแก แกแแฌแงแแกแแแแ แแแแฎแแ แแ โแแแ แซแแแโ แขแแแแแแชแแแแก, แกแแแแ แแกแแแ แแแกแแแ แแแแ แแแแแฉแแแแแแแ แแ แแแแแแแ แ แฎแแ , แ แแ แจแแ แแงแแแ แแแ แแแแ แแ แแ แกแแแแแแ แจแแฅแแแแ แแแแแ แ แแ แกแแแแแแแ, แ แแ แแ แแงแแแ แแแแแ แฏแแแแฃแแ. แแแแ แแ แกแแแแแงแแ แจแแแแซแแแ แแแฅแแ, แ แแ Scratch-แแกแ แแ Arduino-แก แจแแ แฌแงแแ แ แฃแกแฃแ แ แแแแขแแแแจแ แฉแแแ แซแแแแกแฎแแแแแก แฌแงแแแแแแ แแแฉแแแ.
แฌแงแแ แ: www.habr.com