DocsOpen the editorEditor

Running a class

Making a class, the dashboard, and the demo class to try it on.

Look at one first

/class/demo is a sample class, and it opens signed out. The roster is made up and every control on it refuses to change anything with a sentence saying so, but the dashboard is the real one. That is there so you can decide whether this is worth an account before you make one.

Making a class

Go to /class. It is both ends of the thing: a student types the code their teacher read out, and a teacher makes a class and gets a code to read out.

A class needs a name and a seat count. Classes come with Pro and Teacher, not Free; a Free account can join any class as a student, and can try running one with the 30-day trial below. What you may set is capped by your plan:

Plan People in one class Classes you may own
Free none of its own 0
Pro 11 (ten students and you) no limit
Student 11 (ten students and you) no limit
Teacher 41 (forty students and you) no limit
School (quoted) 200 20

These are class seats. A live room on one of your projects is a different limit, set by the same plan: see how many people fit.

You count as one of the people in the class, but not one of the ones you pay for. For one teacher the plan is Teacher: $129 a year or $14 a month with 40 student seats included, everything in Pro for you, as many classes as you like, and Pro's room (unlimited projects, two hundred saves, no badge on exports and embeds) for your students while they are in them. For more than forty students, several teachers, a school, a district or a university, Schools & universities is priced for you: get a written quote on /classroom, or talk to us. Either way the students are shared between all of your classes, and a student in two of them counts once. See the plans.

Not sure yet? Once per account, the 30-day Classroom trial runs one class of up to forty students with everything above, free.

Ask for more seats than your plan holds and the class is made with what the plan allows, and says so rather than letting you believe otherwise.

The dashboard

/class/<id> is the class: the roster, the work assigned, and who has handed what back.

  • The roster: everybody in the class, with a Remove button beside each name and Roster as CSV at the top.
  • The join code, which only you can see. A student who is already in has no use for it.
  • Assignments: each with its title, its due date, how many have submitted, and a grid showing where each student is. Where a submission is a project, you can open it.

The student's dashboard is the same page. It just arrives with their own submissions in it and nobody else's, because the rules about who may see what live on the server rather than in the page.

The wall

The class head has two tabs: Class, which is everything above, and Wall, which is the room while the lesson is on.

The wall is a card for every student on the roster, with their name on it and the circuit they submitted under it. It is whatever they submitted for the newest assignment, or, before they have submitted that, the last thing they submitted to this class. Their other projects are private and never on the wall. The drawing is the circuit itself rather than a screenshot, so it is what the editor would draw this minute, and it keeps up on its own: the page asks for the class every fifteen seconds while the Wall tab is the one in front of you, and stops the moment you leave it or switch browser tab.

A card that has not changed for ten minutes says stuck? beside the time. It asks rather than tells: a student who is thinking looks exactly like a student who is stuck, and the point of the card is that you know which end of the room to walk to. After an hour and a half of nothing the hint goes, because that is not a student who is stuck, it is a student who is not here.

On a phone the wall is two cards across, which is the one you hold while walking the room.

Pressing a card

Every card opens. Press one and that student's work comes up beside the wall on a wide screen, or over it as a full-height sheet on a phone:

  • Their canvas, running. The circuit as it stands on their screen, on the same engine the editor runs. Press Run it and it runs; press a button on the board and it does what it does for them.
  • Their sketch, the file the compiler starts from.
  • Serial, whatever their board prints while it runs here.
  • Last saved, in words, and, on a card that is asking stuck?, a badge that explains itself when you press it: how long the silence has been, what the rule is, and why it is a question rather than an answer.
  • What they changed, where the work came from a starter you assigned: the same diff the submission row draws, against the starter itself.
  • A comment back. The same box as Send feedback on the submission row, writing the same one note per submission, and it is on the student's own class page the next time they open it.
  • Follow, which happens in a live room: the panel points at the room for this assignment where there is one, and says what to start where there is not.
  • Open in the editor, which stages a copy of their circuit in your own account. Nothing you do to it touches their work. Beside it, Open theirs, read-only, which opens their project itself: it is not yours, so the editor says whose it is and saving forks it.

A card that says nothing submitted yet opens too, and says so: they have not submitted a circuit to this class. There is no messaging in Mokxi, so Nudge them puts the class link on your clipboard for you to send the way you already talk to your class.

Opening a student is the one place work leaves its owner's hands without being shared: a teacher can read what somebody in a class they teach submitted to that class, and nobody else can, not even their classmates. The rest of a student's projects stay private to them.

A wall with nobody on it

Before anybody has joined, the Wall tab says so and gives you the next thing to do rather than an empty grid: the invite link for this class, with a button that copies it, and the join code to read out. A student who follows the link lands on the join form with the code already in it and presses Join.

The rules underneath

Three, and every one of them is a test:

  1. A class you are not in is indistinguishable from one that does not exist.
  2. A student sees their own submission and nobody else's. You see the lot, which is what a dashboard is for.
  3. Seats are capped by your plan.

Everything else