👏🏼 🖐🏿 🧒🏾 一年生、遠隔学習、非同期プログラミングについて ☠️ 📯 ⏩

私はダウンシフターです。たまたま、過去3年間、妻と私は窓の外の田園風景、新鮮な空気、鳥のさえずりを楽しんでいました。家の中の便利さ、地元のプロバイダーからの光インターネット、強力な中断のない電源、そして突然現れたコビッドは、突然、大都市から移動するという考えをそれほど奇妙ではありませんでした。

私が熱心にウェブ開発に携わっている間、バックグラウンドのどこかで、妻は私の子供のための学校を選ぶことの問題について定期的に不平を言いました。そして（突然）子供は成長し、学校の質問は直立しました。さて、その時が来ました。一緒にそれを理解しましょう、土地の前の1/6の教育システムの何が問題になっていますか、そしてそれについて私たちは何ができますか？

従来の対面指導方法は、この記事の範囲外にしておきます。普通の学校には、議論の余地のない長所と重大な短所の両方がありますが、ちなみに、最近、強制的な自己隔離が追加されています。ここでは、さまざまな理由で最近ますます多くの親を引き付けている距離と家族の教育オプションを見ていきます。

明確に言うと、距離学習とは「距離学習技術」（DOT）を使用した通常の学校での授業を意味し、家族教育とは自発的に学校を辞めて家族だけで学習することを意味します（実際、これは古き良き外交です）。ただし、いずれの場合も、少なくとも中間認定に合格するためには、子供は利用可能な学校のいずれかに所属している必要があります。

そして今、人生からのいくつかの観察。すでに普通の学校で勉強している子供たちの遠隔学習への強制移籍で、すべてが悲しいです。学童はこの運命の賜物を一種の休暇として認識し、両親は授業中に規律に従うことに慣れておらず、その結果、全体的な学業成績は必然的に低下します。

一年生の場合、特に家族の場合、両親はおそらく、自然な興味と目新しさの効果を利用して、子供を「レールに乗せる」機会があります。個人的には、自立することが主な仕事です。子供と一緒に座って宿題をしていると、~~愚かさの高さ~~を考えます完全に合理的ではありません。もちろん、子供たちに人生で何かを成し遂げてもらいたいのなら、首にぶら下がらないでください。したがって、私の目標は、子供に学び、正しく質問し、一般的には自分の頭で考えることを教えることです。

要点をつかむ。公立学校の選択

たぶん、プログラムやトレーニングスケジュールを選ぶ機会があるので、家族教育がもっと好きです。そして、あなたは物理的に学校に通う頻度を減らすことができます。ただし、9月に驚きがないように、公立学校を選び、監督に子供の配置について話し、冬の終わりに1年生への入学を命じる必要があります。法的な観点からは、教育法は毎年の証明を要求していないようですが、私の経験では、「締め切り」は優れた動機付けであるため、証明があるようにします。どの学校も両手を広げて私たちを受け入れる可能性は低いですが、最寄りの都市で価値のある選択肢を見つけることができると確信しています。

カリキュラムの選択

正確に選択します。専門的な教育を受けずに自分でプログラムを作ろうとするのは合理的ではありません。ロシア電子学校（NES）やモスクワ電子学校（ MES）などの政府の教育リソースがありますが、理論的にはそれで十分ですが...どちらのオプションでも、レッスンプラン、ビデオ、テスト、チュートリアルが提供されます。私が見つけられなかったのは、強制的なカリキュラムでさえ、教科書そのものでした。

そしてここで最も重要なことは欠けています：コミュニケーション。無限のビデオを見せて子供にテストをチェックさせることで子供を教えることはうまくいきません。つまり、完全に独立してレッスンを実施するか、オンラインスクールの1つを選択する必要があります。

オンラインスクールの選択

始めたところにほぼ戻っています。リモコン？さて、彼女を詳しく見てみましょう。教育プロセスをリモートでどのように整理できますか？これは多くの質問を提起します、私は重要なものだけを提起します：

*ライブコミュニケーション。学校は何を提供していますか？スカイプ、せいぜいティムス。 Skypeレッスン？本当に？私が間違っていなければ、2020年です。一年生の前で美しいマルチカラーのボタンが付いたいくつかのウィンドウを開き、彼がそれらを押さないのを待ちますが、退屈な叔父や叔母に半日素直に耳を傾けますか？私はそのような子供を見たことがありません。あなたも？

* 宿題。より正確には、それはどのようにしてテストのために教師に届きますか？実際、これは本当に難しい質問であり、おそらく原則的には解決されていません。既存のオプション：

, . --, , , , - .
. , - .
. , .
. , , , , ? . , , .
. , , . , , , . , . . , , , , . .

* 見積り。明らかに、レッスンで与えられた成績と宿題をチェックするときは、両親が利用できる電子日記に分類されるべきです。そして彼らはそこに着きます。しかし、すぐにではありません。金のドームのある一流のリセウムの1つを卒業した年長の子供たちに尋ねました（皮肉なことに、情報の偏りがあります）、これはなぜですか？その答えは、正直、私を驚かせました。教師は一枚の紙に成績を書き留め、レッスンの後、州のポータルでこの非常に電子的な日記にそれらを運転することがわかりました。そして、これはテスラエロンムスクが広大なスペースを耕している間...

さて、少し技術的な調査をして、この状況に客観的な理由があるかどうかを確認する時が来ましたか？

架空の理想的な学習プラットフォームの要件を定義しましょう。実際、すべてが単純です。子供たちはレッスンにとどまり、教師の言うことと見せることに焦点を合わせ、必要に応じて質問に答え、必要に応じて手を上げる必要があります。基本的に、教師のカメラ、プレゼンテーション、またはホワイトボードからのストリームを含むフルスクリーンウィンドウが必要です。これを実現する最も簡単な方法は、WebRTCテクノロジーを使用することです。（リアルタイム通信、リアルタイム通信）。これは、多かれ少なかれ最新のブラウザで機能し、追加の機器を購入する必要がなく、さらに、高品質の接続を提供します。そして、はい、少なくとも必要なJSメソッドnavigator.mediaDevices.getUserMedia（）がpromiseを返すため、この標準では非同期プログラミングが必要です。すべてが明確なようです、私はそれを実装し始めています。

フレームワークの選択についての叙情的な逸脱

, «» JavaScript , . jQuery. , JS :

//  
element = $(selector);
element = document.querySelector(selector);

//    
element2 = element.find(selector2);
element2 = element.querySelector(selector2);

//  
element.hide();  //   display: none
element.classList.add('hidden');

, CSS «hidden», , opacity transition, fadeIn/fadeOut CSS. , JS !

//   onClick
element.click(e => { ... });
element.onclick = (e) => { ...  }

//  
element.toggleClass(class_name);
element.classList.toggle(class_name);

//  div
div = $("<div>");
div = document.createElement("div");

//   div  element
// (  ,   )
element.append(div);
element.append(div);

. .. , JS , . , , «» JS !

WebRTCは、ポイントツーポイント（p2p）テクノロジを使用して、ブラウザ間の直接通信用に設計されています。ただし、この接続を確立するには、ブラウザは相互に通信する意図を通知する必要があります。これにはアラームサーバーが必要です。

「フルメッシュ」トポロジを使用した単純なビデオチャットの基本的な実装の例

'use strict';

(function () {
    const selfView = document.querySelector('#self-view'),
        remoteMaster = document.querySelector('#remote-master'),
        remoteSlaves = document.querySelector('#remote-slaves');

    let localStream,
        selfStream = null,
        socket = null,
        selfId = null,
        connections = {};

    // ***********************
    // UserMedia & DOM methods
    // ***********************

    const init = async () => {
        try {
            let stream = await navigator.mediaDevices.getUserMedia({
                audio: true, video: {
                    width: { max: 640 }, height: { max: 480 }
                }
            });
            localStream = stream;

            selfStream = new MediaStream();

            stream.getVideoTracks().forEach(track => {
                selfStream.addTrack(track, stream); // track.kind == 'video'
            });
            selfView.querySelector('video').srcObject = selfStream;

        } catch (e) {
            document.querySelector('#self-view').innerHTML =
                '<i>     </i>';
            console.error('Local stream not found: ', e);
        }
        wsInit();
    }

    const createRemoteView = (id, username) => {
        let iDiv = document.querySelector('#pc' + id);
        if (!iDiv) {
            iDiv = document.createElement('div');
            iDiv.className = 'remote-view';
            iDiv.id = 'pc' + id;

            let iVideo = document.createElement('video');
            iVideo.setAttribute('autoplay', 'true');
            iVideo.setAttribute('playsinline', 'true');

            let iLabel = document.createElement('span');

            iDiv.append(iVideo);
            iDiv.append(iLabel);

            if (!remoteMaster.querySelector('video')) {
                remoteMaster.append(iDiv);
                iLabel.textContent = '';
            } else {
                remoteSlaves.append(iDiv);
                iLabel.textContent = username;
            }
            remoteMaster.style.removeProperty('display');
        }
    }

    // *******************************
    // Signaling (Web Socket) methods
    // *******************************

    const wsInit = () => {
        socket = new WebSocket(SIGNALING_SERVER_URL);

        socket.onopen = function (e) {
            log('[socket open]  ');
        }

        socket.onmessage = function (event) {
            log('[socket message]    ', event);

            wsHandle(event.data);
        }

        socket.onclose = function (event) {
            if (event.wasClean) {
                log('[close]   , ' +
                    `=${event.code} =${event.reason}`);
            } else {
                log('[socket close]  ', event);
            }
            clearInterval(socket.timer);
        }

        socket.onerror = function (error) {
            logError('[socket error]', error);
        }

        socket.timer = setInterval(() => {
            socket.send('heartbeat');
        }, 10000);
    }

    const wsHandle = async (data) => {
        if (!data) {
            return;
        }
        try {
            data = JSON.parse(data);
        } catch (e) {
            return;
        }

        switch (data.type) {
            case 'handshake':
                selfId = data.uid;
                if (!Object.keys(data.users).length) {
                    createRemoteView(selfId, '');
                    remoteMaster.querySelector('video').srcObject =
                        selfStream;
                    selfView.remove();
                    break;
                } else {
                    selfView.style.removeProperty('display');
                }
                for (let id in data.users) {
                    await pcCreate(id, data.users[id]);
                }
                break;
            case 'offer':
                await wsHandleOffer(data);
                break;
            case 'answer':
                await wsHandleAnswer(data)
                break;
            case 'candidate':
                await wsHandleICECandidate(data);
                break;
            default:
                break;
        }
    }

    const wsHandleOffer = async (data) => {
        let pc = null;

        if (!connections[data.src]) {
            await pcCreate(data.src, data.username);
        }

        pc = connections[data.src].pc;

        // We need to set the remote description to the received SDP offer
        // so that our local WebRTC layer knows how to talk to the caller.
        let desc = new RTCSessionDescription(data.sdp);

        pc.setRemoteDescription(desc).catch(error => {
            logError('handleOffer', error);
        });

        await pc.setLocalDescription(await pc.createAnswer());

        wsSend({
            type: 'answer',
            target: data.src,
            sdp: pc.localDescription
        });

        connections[data.src].pc = pc; // ???
    }

    const wsHandleAnswer = async (data) => {
        log('*** Call recipient has accepted our call, answer:', data);

        let pc = connections[data.src].pc;

        // Configure the remote description,
        // which is the SDP payload in our 'answer' message.

        let desc = new RTCSessionDescription(data.sdp);
        await pc.setRemoteDescription(desc).catch((error) => {
            logError('handleAnswer', error);
        });
    }

    const wsHandleICECandidate = async (data) => {
        let pc = connections[data.src].pc;

        let candidate = new RTCIceCandidate(data.candidate);

        log('*** Adding received ICE candidate', candidate);

        pc.addIceCandidate(candidate).catch(error => {
            logError('handleICECandidate', error);
        });
    }

    const wsSend = (data) => {
        if (socket.readyState !== WebSocket.OPEN) {
            return;
        }
        socket.send(JSON.stringify(data));
    }

    // ***********************
    // Peer Connection methods
    // ***********************

    const pcCreate = async (id, username) => {
        if (connections[id]) {
            return;
        }
        try {
            let pc = new RTCPeerConnection(PC_CONFIG);

            pc.onicecandidate = (event) =>
                pcOnIceCandidate(event, id);
            pc.oniceconnectionstatechange = (event) =>
                pcOnIceConnectionStateChange(event, id);
            pc.onsignalingstatechange =  (event) =>
                pcOnSignalingStateChangeEvent(event, id);
            pc.onnegotiationneeded = (event) =>
                pcOnNegotiationNeeded(event, id);
            pc.ontrack = (event) =>
                pcOnTrack(event, id);

            connections[id] = {
                pc: pc,
                username: username
            }

            if (localStream) {
                try {
                    localStream.getTracks().forEach(
                        (track) => connections[id].pc.addTransceiver(track, {
                            streams: [localStream]
                        })
                    );
                } catch (err) {
                    logError(err);
                }
            } else {
                // Start negotiation to listen remote stream only
                pcOnNegotiationNeeded(null, id);
            }
            createRemoteView(id, username);
        } catch (error) {
            logError('Peer: Connection failed', error);
        }
    }

    const pcOnTrack = (event, id) => {
        let iVideo = document.querySelector('#pc' + id + ' video');
        iVideo.srcObject = event.streams[0];
    }

    const pcOnIceCandidate = (event, id) => {
        let pc = connections[id].pc;

        if (event.candidate && pc.remoteDescription) {
            log('*** Outgoing ICE candidate: ' + event.candidate);
            wsSend({
                type: 'candidate',
                target: id,
                candidate: event.candidate
            });
        }
    }

    const pcOnNegotiationNeeded = async (event, id) => {
        let pc = connections[id].pc;
        try {
            const offer = await pc.createOffer();

            // If the connection hasn't yet achieved the "stable" state,
            // return to the caller. Another negotiationneeded event
            // will be fired when the state stabilizes.
            if (pc.signalingState != 'stable') {
                return;
            }

            // Establish the offer as the local peer's current
            // description.
            await pc.setLocalDescription(offer);

            // Send the offer to the remote peer.
            wsSend({
                type: 'offer',
                target: id,
                sdp: pc.localDescription
            });
        } catch(err) {
            logError('*** The following error occurred while handling' +
                ' the negotiationneeded event:', err);
        };
    }

    const pcOnIceConnectionStateChange = (event, id) => {
        let pc = connections[id].pc;
        switch (pc.iceConnectionState) {
            case 'closed':
            case 'failed':
            case 'disconnected':
                pcClose(id);
                break;
        }
    }

    const pcOnSignalingStateChangeEvent = (event, id) => {
        let pc = connections[id].pc;

        log('*** WebRTC signaling state changed to: ' + pc.signalingState);

        switch (pc.signalingState) {
            case 'closed':
                pcClose(id);
                break;
        }
    }

    const pcClose = (id) => {
        let remoteView = document.querySelector('#pc' + id);

        if (connections[id]) {
            let pc = connections[id].pc;
            pc.close();
            delete connections[id];
        }
        if (remoteView) {
            remoteView.remove();
        }
    }

    // *******
    // Helpers
    // *******

    const log = (msg, data) => {
        if (!data) {
            data = ''
        }
        console.log(msg, data);
    }

    const logError = (msg, data) => {
        if (!data) {
            data = ''
        }
        console.error(msg, data);
    }

    init();
})();

シグナリングサーバーはPythonaiohttpフレームワーク上で作成され、WebRTC要求を簡単にプロキシする単純な「ビュー」です。この例のサーバーへの接続は、Webソケットを介して行われます。さらに、単純なテキストチャットデータがシグナリングチャネルを介して送信されます。

シグナリングサーバーの実装例

import json
from aiohttp.web import WebSocketResponse, Response
from aiohttp import WSMsgType
from uuid import uuid1
from lib.views import BaseView


class WebSocket(BaseView):
    """ Process WS connections """

    async def get(self):
        username = self.request['current_user'].firstname or ''

        room_id = self.request.match_info.get('room_id')

        if room_id != 'test_room' and
            self.request['current_user'].is_anonymous:
            self.raise_error('forbidden')  # @TODO: send 4000

        if (self.request.headers.get('connection', '').lower() != 'upgrade' or
            self.request.headers.get('upgrade', '').lower() != 'websocket'):
            return Response(text=self.request.path)  # ???

        self.ws = WebSocketResponse()
        await self.ws.prepare(self.request)

        self.uid = str(uuid1())

        if room_id not in self.request.app['web_sockets']:
            self.request.app['web_sockets'][room_id] = {}

        self.room = self.request.app['web_sockets'][room_id]

        users = {}
        for id, data in self.room.items():
            users[id] = data['name']

        ip = self.request.headers.get(
            'X-FORWARDED-FOR',
            self.request.headers.get('X-REAL-IP',
            self.request.remote))

        msg = {
            'type': 'handshake',
            'uid': str(self.uid),
            'users': users, 'ip': ip}
        await self.ws.send_str(json.dumps(msg, ensure_ascii=False))

        self.room[self.uid] = {'name': username, 'ws': self.ws}

        try:
            async for msg in self.ws:
                if msg.type == WSMsgType.TEXT:
                    if msg.data == 'heartbeat':
                        print('---heartbeat---')
                        continue

                    try:
                        msg_data = json.loads(msg.data)

                        if 'target' not in msg_data or
                            msg_data['target'] not in self.room:
                            continue

                        msg_data['src'] = self.uid

                        if 'type' in msg_data and 'target' in msg_data:
                            if msg_data['type'] == 'offer':
                                msg_data['username'] = username
                        else:
                            print('INVALID DATA:', msg_data)
                    except Exception as e:
                        print('INVALID JSON', e, msg)

                    try:
                        await self.room[msg_data['target']]['ws'].send_json(
                            msg_data);
                    except Exception as e:
                        if 'target' in msg_data:
                            self.room.pop(msg_data['target'])

        finally:
            self.room.pop(self.uid)

        return self.ws

WebRTCテクノロジを使用すると、ビデオ通信に加えて、ディスプレイまたは別のアプリケーションのコンテンツをキャプチャする許可をブラウザに与えることができます。これは、オンラインレッスン、ウェビナー、またはプレゼンテーションを行うときに不可欠です。よし、使ってみよう。

私はビデオ通信の現代的な可能性に夢中になり、クラスで最も重要な主題であるインタラクティブホワイトボードについてほとんど忘れていました。ただし、基本的な実装は非常に簡単なので、この記事をそれで過負荷にすることはありません。キャンバスを追加し、 onmousemove（タブレットの場合はontouchmove）のマウス移動イベントをリッスンし、結果の座標を同じシグナリングサーバーを介して接続されているすべてのポイントに送信します。

インタラクティブホワイトボードのテスト

ここでは、タブレット、デジタイザー、生きている子供が必要です。同時に、手書き入力のデジタル化の可能性を確認します。

まず、Android4.4の古いGalaxyTabタブレット、自家製のスタイラス、そしてキャンバスの背景として最初に出会ったコピーブックを取り上げました。追加のプログラムはインストールしませんでした。結果は私を落胆させました：私のタブレットは書くのに絶対に適していません！つまり、指をそれに沿って動かすことは問題ありませんが、下の写真のような巨大なものであっても、スタイラスを文字の輪郭に入れることはすでに問題です。さらに、ガジェットは描画の過程で鈍くなり始め、その結果、線が途切れます。さらに、私は子供に手首を画面に乗せないようにすることができなかったため、手元に追加の塗りつぶしが残り、タブレット自体がさらに遅くなり始めました。結論：ホワイトボードに書き込むための通常のタブレットは適していません。その機能の最大は、画面上でかなり大きな数字を指で動かすことです。しかし、これを学童に提供するには遅すぎます。

さて、これは純粋に理論的な研究ですよね？次に、デジタイザー（別名グラフィックタブレット）のWacom Bamboo A8形式を使用して、子供を監視します。

私の6歳の被験者は、彼の人生で初めてグラフィックペン付きのラップトップを受け取ったことに注意してください。ペンを使用するための基本的なスキルを習得するのに10分かかりました。すでに、2番目のレッスンでは、子供は非常に自信を持ってタブレットを使用し、ボードから独立して消去し、顔、花、犬を描き、イプシロンで利用可能なボタンを突くようになり、同時に次のような質問をしました。「なぜ彼らは学校で手を上げるのですか？」しかし、その結果は常に多くのことが望まれていました。事実、デザイナーやアーティストは画像の断片を最大化して要素を描画し、線を正確にします。ここでは、ボード全体が1：1のスケールで表示されます。ここと大人は列に落ちません。これが私たちが得たものです：

最終評決：手書きは問題外ではありません。そして、私たちが子供たちに「手を差し伸べる」ことを望むなら、私たちは自分たちでこれを達成する必要があります、紙の上で、学校はこれを助けません。

子供は私のすべての実験を熱心に受け止め、さらにそれ以来、私を尻尾で追いかけ、「レシピをオンにする」ように頼んできたと言わなければなりません。すでに十分に、習得したスキルは、まったく異なる目的のためにのみ、彼に役立ちます。

とにかく、実験の結果、私は実際にMVPを手に入れました-最小限の実行可能な製品、ほぼビデオ/オーディオ会議、共有画面、インタラクティブホワイトボード、シンプルなテキストチャット、挙手ボタンなど、オンラインレッスンに適しています。これは、子供が突然マイクを持っていない場合に備えています。はい、これは特にレッスンを学んでいない子供たちの間で起こります。

しかし、この蜂蜜の樽には、残念ながら、タールスプーンがいくつかあります。

WebRTCのテスト

スプーン番号1。私たちのビデオ通信はクライアント間の直接接続を使用するため、最初のステップはそのようなソリューションのスケーラビリティをテストすることです。テストでは、デュアルコアi5-3230Mを搭載した古いラップトップを使用して、Webカメラが無効になっているクライアントを接続し始めました。つまり、1対多モードをエミュレートしました。

ご覧のとおり、実験用ラップトップは5人のクライアントに多かれ少なかれ快適にブロードキャストできます（ CPU負荷が60％以内の場合）。これは、発信ビデオストリームの解像度が720p（640x480px）に、フレームレートが15fpsに低下した場合に提供されます。原則として、それほど悪くはありませんが、数十人の学生のクラスを接続する場合、カスケードを優先して「フルメッシュ」を放棄する必要があります。つまり、最初の5つのクライアントのそれぞれがストリームを次の5つにプロキシします。

スプーン番号2。クライアント間に直接対話型接続（ICE）を作成するには、クライアントはファイアウォールとNATをバイパスする必要があります。これを行うために、WebRTCはSTUNサーバーを使用して、クライアントに外部接続パラメーターを通知します。ほとんどの場合、これで十分であると考えられています。しかし、私はほとんどすぐに「幸運」でした。

ご覧のとおり、デバッガーはICE接続が不可能であると文句を言い、TURNサーバーを接続する必要があります。つまり、リレーです。そして、これはすでに高価です。ここでは、シンプルなシグナリングサーバーが不可欠です。結論-すべてのストリームをメディアサーバーに渡す必要があります。

メディアサーバー

テストには、aiortcを使用しました。興味深い開発であり、WebRTCを介してブラウザをサーバーに直接接続できます。個別のシグナリングは必要ありません。接続自体のデータチャネルを使用できます。これは機能し、すべてのテストポイントが問題なく接続されました。しかし、パフォーマンスの問題。同じ720pと15fpsの制限を持つビデオ/オーディオストリームの単純なエコーは、テストVDSの仮想CPUの50％を消費しました。さらに、負荷が100％に増加すると、ビデオストリームをクライアントにアンロードする時間がなくなり、メモリが詰まり始め、最終的にサーバーが停止します。明らかに、私たちがI / O処理に使用するのが大好きなPythonは、CPUにあまり依存していません。Janusなど、より専門的なソリューションを探す必要がありますまたは Jitsy。

いずれにせよ、私の見積もりによれば、完全なソリューションには、部屋（クラス）ごとに1コアの割合で専用サーバーが必要になります。これにはすでに費用がかかり、単純なテストを超えているため、この時点で、研究の最初のフェーズが完了したと見なします。

結論

1.控えめに言って、ロシア連邦の公式ポータルで、以前の潜在的な敵番号1（ここではMicrosoft Teamsについて）のプログラムに登録するためのダウンロード手順とリンクを見るのは奇妙です。そして、これは制裁と輸入代替の時代です。

いいえ、個人的に私は人々の友情、そして一般的にはあらゆる種類の寛容のためですが、私の髪が逆立っているのは本当にそのような「統合」からの私だけですか？私たちの開発はありませんか？

2. MES / NESと学校の統合。実際、MES開発者は素晴らしく、Yandex.tutorとの統合も行っています。レッスン中のリアルタイムのグレーディングはどうですか？APIはいつありますか？それとも私は何かに気づいていませんか？

3.距離や家族の教育形態を選択するときは、自分自身に正直である必要があります。子供の教育の責任を学校に移すことはできません。レッスンの実施（家族教育の場合）、規律の維持、自己組織化（いずれの場合も）のすべての作業は、完全に親に委ねられています。これを認識し、授業の時間を見つける必要があります。ただし、大家族では、これは問題にはならないはずです。

4.広告と見なされないように、ここでは選択したオンライン学校へのリンクを含めません。中価格帯の私立学校を選んだとだけ言っておきます。いずれにせよ、最終的な結果は子供によって異なり、9月までに受け取ります。

それとも、ここで始まった開発を論理的な結論に導き、あなた自身の学校を組織することは理にかなっていますか？どう思いますか？教育の分野で専門的な知識と経験を持つ志を同じくする人々はいますか？

便利なリンク：

ロシア電子学校

モスクワ電子学校開発者向け

MESライブラリ

一年生、遠隔学習、非同期プログラミングについて