Answers.Body: <p>My suggestion would be to utilize seprate tools for elements of the process rather than try to find a packaged solution, or modify an existing tool which is 'not quite right' for the task.</p>
  
  <p>Quick summary is:</p>
  
  <ul>
  <li>use Discord for communications, text and/or audio
  
  <ul>
  <li>Restricted channels for each pair to utilize while coding</li>
  <li>Open channel for students to contact the instructor</li>
  </ul></li>
  <li>use the GoLive feature of Discord for the "driver" to stream their active IDE to the "navigator" (GoLive will stream a "terminal" window, it does not have to be a game.)</li>
  <li>use <code>git</code> to "lock in" the code between role switches with commits</li>
  <li>use GPG keys for signing of commits and to authenticate the SSH pushes</li>
  <li>use GitLab as the remote repository</li>
  </ul>
  
  <h2>Use Discord for communications</h2>
  
  <p>As the instructor:</p>
  
  <ol>
  <li>Create a Discord server</li>
  <li>Create a public text channel for the students to reach you in</li>
  <li>Create a public text channel for the students to share in (you can monitor, but don't communicate here)</li>
  <li>Create a <em>role</em> for each assigned student pair</li>
  <li>Create a private text channel for each <em>role</em> above</li>
  <li>Create a private audio channel for each <em>role</em> above</li>
  <li>Enable each <em>role</em> to send/read messages, or connect and use GoLive, in the <em>role</em>-specific text and voice channels</li>
  <li>As students join, however you get them to connect, assign them to the <em>role</em> which matches the assigned pairings</li>
  </ol>
  
  <p>As the owner of the server the instructor will be able to read the chat in all text channels, hear the conversation in any audio channel, and view any of the windows being streamed. Instructor preference and style take priority, but my suggestion is to limit any messages sent by the instructor to the designated channel. Moderator type actions can, and of course should, be taken in any channel. Going remote still leave "classroom discipline" in the instructor's hands.</p>
  
  <p>As the school term progresses, it's likely that pairs are reassigned frequently. Perhaps as often as each new project. Once a project is graded, the associated text channel could be reset, or removed.</p>
  
  <h2>Use <code>git</code></h2>
  
  <p>While <code>git</code> may not be <em>The one <strong>true</strong> source control system</em>, it is a popular one. The command line use of it can be quite complicated, especially for advanced purposes. The basics of it, however, are quite manageable for students. GUI tools also exist, though I'm reluctant to endorse any one, or even recommend their use. With students learning to use <code>git</code> it is probably better for them to learn the CLI commands, which will work on any OS, and on any system with <code>git</code> installed. The GUI they learn might not work on the system they have to use later, for work or for advanced classes. The GUI probably won't work if they have to use SSH for any reason as well.</p>
  
  <p>Using <code>git</code>, as long as both students have access to the repo, allows for one to make changes, commit the results, and pass control to the other when they switch roles. As an extra benefit, since the current "navigator" will have the last committed version locally, they can scan through the file(s) to review other parts while directing the "driver". Ensuring that identifier names and parameters are used correctly, for example, without disturbing the "driver" with those details, allowing the driver to concentrate on the section of code being changed.</p>
  
  <p>As a benefit to the students, they'll have the ability to unroll changes that were leading down a dead-end. As a benefit to the instructor, each commit will be blamed to the student driving. Additionally, by following the diffs, it's likely that when the team gets lost in the weeds, the instructor can see what thinking started the problem, and help them to see the way out.</p>
  
  <h2>Use GPG keys</h2>
  
  <p>The "remote" aspect of this is challenging for instructors to "watch" the students work. Having to worry about who is doing the work and who is not only adds to the work load. Requiring that the students GPG-sign their commits can help with that some. Not only will the repository assign the updates to the user, it will also verify that the user claiming the updates is the same one who signed them. There is no encryption involved, just a signing of the commit to prove who made it. Using it, however, might require the students to install GnuPG on their systems. Encouraging them to do so shouldn't cause any issue, and it can be a good habit to develop for later as well.</p>
  
  <p>The process of setting up a key for use with the <code>git</code> program, and for connecting to the remote repository is fairly simple. Even from the command line.</p>
  
  <ol>
  <li>Generate the key pair to use. The key pair needs to have both singing and authorization capabilities.</li>
  </ol>
  
  <pre><code>gypsy@spellweaver:~&gt; gpg --quick-generate-key "Student Name &lt;email.name@some-school.edu&gt;" future-default auth,sign
  We need to generate a lot of random bytes. It is a good idea to perform
  some other action (type on the keyboard, move the mouse, utilize the
  disks) during the prime generation; this gives the random number
  generator a better chance to gain enough entropy.
  gpg: key A822359C643A77A4 marked as ultimately trusted
  gpg: revocation certificate stored as '/home/gypsy/.gnupg/openpgp-revocs.d/11716FF672B9DD368C174F26A822359C643A77A4.rev'
  public and secret key created and signed.
  
  pub   ed25519/A822359C643A77A4 2020-03-19 [SCA] [expires: 2022-03-19]
      Key fingerprint = 1171 6FF6 72B9 DD36 8C17  4F26 A822 359C 643A 77A4
      Keygrip = 92F62A329D3CBBBE64BFA8DABC6F4348623AB256
  uid                            Student Name &lt;email.name@some-school.edu&gt;
  </code></pre>
  
  <ol start="2">
  <li>The ASCII version of the public key will be needed when setting up the repository.
  This block will be copy-pasted to the repository within the user's account settings.</li>
  </ol>
  
  <pre><code>gypsy@spellweaver:~&gt; gpg --armor --export A822359C643A77A4
  -----BEGIN PGP PUBLIC KEY BLOCK-----
  
  mDMEXnMHZxYJKwYBBAHaRw8BAQdAjh6qOGnp5b0GTNZEHL4wIrIljwxLlxfU8/F5
  l8TZVNC0KVN0dWRlbnQgTmFtZSA8ZW1haWwubmFtZUBzb21lLXNjaG9vbC5lZHU+
  iJ0EExYKAEUWIQQRcW/2crndNowXTyaoIjWcZDp3pAUCXnMHZwIbIwUJA8JnAAsL
  CQ0IDAcLCgMBBAYVCgkICwMFFgMBAgACHgECF4AACgkQqCI1nGQ6d6RXEAD/Rdhz
  kh+gNvnO367JYqdoIwFiIsW4a2mq3d4nqNE6migBAM3m8cMO2Ww2u5+O7l8P4GuI
  EMTlK2WWckAEJUGS1pMO
  =6LSb
  -----END PGP PUBLIC KEY BLOCK-----
  
  </code></pre>
  
  <ol start="3">
  <li>The public key needs to be saved in SSH format.</li>
  </ol>
  
  <pre><code>gypsy@spellweaver:~&gt; gpg --output id_ed25519.pub --export-ssh-key email.name@some-school.edu
  </code></pre>
  
  <ol start="4">
  <li>The public key will be needed when setting up the repository on GitLab.
  The last line is what will be copy-pasted in the settings of the repository for the SSH key.</li>
  </ol>
  
  <pre><code>gypsy@spellweaver:~&gt; cat id_ed25519.pub
  ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAII4eqjhp6eW9BkzWRBy+MCKyJY8MS5cX1PPxeZfE2VTQ openpgp:0x643A77A4
  </code></pre>
  
  <ol start="5">
  <li>the <code>git</code> program needs to be set to always gpg-sign commits and told which key to use</li>
  </ol>
  
  <pre><code>git config --global commit.gpgsign "true"
  git config --global user.signingkey "A822359C643A77A4"
  </code></pre>
  
  <h2>Use GitLab as the remote repository</h2>
  
  <p>Usually GitHub vs GitLab is more about personal preference than any project-based requirements. The granularity of permissions in GitLab is better than GitHub, allowing the instructor to grant access to the assignment repos on a per-user basis. GitLab allows for unlimited private repositories without having to create a paid account. Let's face it, as a rule educators don't have the spare funds to support enterprise level tooling. GitLabs give for free what GitHub will charge for. As it is student work, private repos seems more appropriate on two grounds. First, normally student assignments are not available to the general public. Even more so when dealing with under-age students. Second, by having private repos, with only the pair of students working on it being granted access, the ability to copy one team's work by another team is greatly reduced. </p>
  
  <p>Three additional factors available from GitLab which might be useful are: 1) Discord Notifications, 2) their Continuous Integration (CI) pipeline, and 3) the ability to install a local, or self-hosted, GitLab for greater security. Depending on the language being use, the CI pipeline might help in keeping variations in build environments between student systems, or between their system and the instructor's system, from hiding or creating errors.</p>
  
  <h2>Tidbits and Notes</h2>
  
  <p>One possible downside to Discord is that it <em>can</em> also be used for video calls. That, however, is a something which is available through the "friends" section rather than in the "server" you would be responsible for, so it shouldn't count against you, or the application.</p>
  
  <p>A bonus for Discord is that the odds are high that most of the students already have it installed, and know how to use it. They probably know how to use it better than the instructor would.</p>
  
  <p>For the current crisis (COVID-19) Discord has increased the size of GoLive streams to 50. That shouldn't matter unless it's decided to us the GoLive feature for the instructor to do demonstrations, which is also a possibility.</p>
  
  <p>If the students have an assigned email account from the school, it is probably a good idea to require that such email be the one associated with the GPG keys and the accounts on GitLab. Official required communications should be done by email using that address as well. Assignment instructions, due dates, grades, etc., rather in the untracked space of Discord.</p>
  
  <p>To "invite" the students to the Discord server, create short-lived, single-use invites for each student, and send that in an email to them rather than a general invited for the class.</p>
  
  <p>For most Linux systems, <code>git</code> is a simple install, directly from the default software repositories. For Windows it takes a bit more work. A guide, which seems to be pretty good, is <a href="https://www.computerhope.com/issues/ch001927.htm" rel="nofollow noreferrer">How to install and use Git on Windows</a>.</p>
  
  <p>An advantage, and possible disadvantage of using the GoLive option is that each student can have their own version of the IDE, customized to their preferences. It's even possible they could use a different IDE than they would in class, and different from what their partner is using.</p>
  
  <p>The potential problem with this is that they could become lost in the IDE and the instructor, having never used <em>that one</em> might not be able to help.</p>
  
  <p>An unplanned benefit could be that new insights into student preferences, including IDE choices, can be obtained by noticing which IDE students gravitate towards, and how they use them. Once classroom instruction is able to resume, a change of IDE for in-class use might be in order.</p>
  
  <p>The 24/7 availability of the tools can get the students into the habit of "calling" the instructor an anytime, without thinking that there are other things to do, or classes to work with. Setting a time for "class" where you will be available on the server for direct contact, perhaps during the same time-span as class was held when it could be held. To avoid the appearance of always being available it might be worth creating a different server for each class, keeping your "office hours" on each server in turn.</p>
  
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-03-19T10:25:02.543Z
Answers.Text: Switching between driver and navigator should be simple, quick, and seamless. Is it with this solution?
Answers.UserDisplayName: Buffy
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-03-19T11:21:38.377Z
Answers.Text: I am, as I *often* am, blown away by your post. Thank you!
Answers.UserDisplayName: Ben I.
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-03-19T20:01:25.580Z
Answers.Text: @buffy It should be seamless. Driver does save, commit, push. New driver does pull, open (or refresh) and starts editing
Answers.UserDisplayName: Gypsy Spellweaver
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-03-19T08:52:04.190Z
Answers.LastActivityDate: 2020-03-19T08:52:04.190Z
Answers.UserDisplayName: Gypsy Spellweaver
Answers.Body: <p>I've been experimenting with AWS Cloud9 with a view to remote pair-programming (at the professional level). Also, as a means of (vocational level) coaching of young professionals currently working-from-home. Might it meet your needs?</p>
  
  <p>Also, Amazon have various educational tie-ups, which your school/system might investigate.</p>
  
  <p>Disclaimers: AWS is subject to US 'export controls'; some don't like using such service-providers in principle; I have no link to AWS other than as a user.</p>
  
  <p>Regards =dn</p>
  
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-03-21T20:01:57.730Z
Answers.LastActivityDate: 2020-03-21T20:01:57.730Z
Answers.UserDisplayName: d-n
Answers.Body: <p>In the past I've successfully used XPairtise for Eclipse. The Eclipse marketplace shows this and a couple of others: <a href="https://marketplace.eclipse.org/category/free-tagging/pair-programming" rel="nofollow noreferrer">https://marketplace.eclipse.org/category/free-tagging/pair-programming</a></p>
  
  <p>A separate voice or text channel might be good to use with it. </p>
  
  <p>But you want something with a fast and seamless switch between driver and navigator and also integration with the testing system. Eclipse with a plugin gives you that. The switch of roles should be as quick as passing the keyboard from one person to the other in co-located programming. Here it might be "click a button to switch roles." </p>
  
  <p>Note that XPairtise hasn't been updated for a while and the others listed are newer. I haven't tried them.</p>
  
  <p>A web search for "distributed pair programming" will probably give more information.</p>
  
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-03-19T11:25:43.393Z
Answers.Text: I can't believe there are plugins that do this.  How simple!  I use Eclipse, but most of my students use IntelliJ, but I am sure there are similar plugins there as well.  Fantastic!
Answers.UserDisplayName: Ben I.
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-03-19T12:31:41.303Z
Answers.Text: An advantage of Eclipse is that it is agnostic about the language you program in, with lots of support for other languages than Java. I don't know if that is also true of IntelliJ, but if not then learning Eclipse leverages to many other things. It can even be used for non-programming tasks. Students shouldn't need to learn an entirely different tool set for each course they take. The Eclipse Marketplace has a huge number of resources.
Answers.UserDisplayName: Buffy
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-03-20T01:13:23.867Z
Answers.Text: I'd guess that without a real-time communication channel, independent of the code, pair programming is reduced to relay programming. The navigator has to tell the driver what to do in the moment, not as a road map to follow until it's their turn. Text chat is workable, while voice chat reduces the distraction of having to "notice" that the partner has said something, and resembles the in-person pair programming more fully. Soros includes a chat window as part of the plugin (from the screen shots anyway.)
Answers.UserDisplayName: Gypsy Spellweaver
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-03-20T11:59:23.477Z
Answers.Text: @GypsySpellweaver XPairtise (maybe others) provide a text based channel. I can't remember whether there is a second cursor the navigator controls. But the navigator isn't a puppet master. They comment only as necessary. The point out potential design flaws, suggest spelling changes for code clarity and such. The driver has complete control and isn't overridden by the navigator. The driver takes a microscopic view of the code, the navigator a macroscopic view. This difference of views is natural and has been observed. The power is in the integration of the two views.
Answers.UserDisplayName: Buffy
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-03-20T12:00:11.207Z
Answers.Text: But a higher bandwidth channel (voice...) is certainly helpful.
Answers.UserDisplayName: Buffy
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-03-19T10:23:30.633Z
Answers.LastActivityDate: 2020-03-19T12:05:38.303Z
Answers.LastEditDate: 2020-03-19T12:05:38.303Z
Answers.UserDisplayName: Buffy
Answers.Body: <p>Keep it simple and integrate into tools that your school is already using as much as possible.</p>
  
  <p>For example, my university is using MS Teams (which <a href="https://products.office.com/en-us/microsoft-teams/remote-learning" rel="nofollow noreferrer">may currently be free for everyone</a>). To do pair programming, each pair of students sets up a call with each other and one person shares their IDE window (we use Thonny). The other one then requests control, so either person can play either role (driver or navigator).</p>
  
  <p>(Edits welcome for corresponding info about Zoom.)</p>
  
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2020-03-26T20:39:44.187Z
Answers.LastActivityDate: 2020-03-26T20:39:44.187Z
Answers.UserDisplayName: Ken Arnold
Body: <p>We've done pair programming for years with the rule of two kids, one screen, and the kids sitting next to each other.  We have found this to be a tremendously valuable process.</p>
  
  <p>Now that all instruction is distance learning due to COVID-19, are there virtual solutions that would allow our students to simulate something like this?</p>
  
Comments.ContentLicense: CC BY-SA 4.0
Comments.CreationDate: 2020-03-18T20:56:10.053Z
Comments.Text: Have you considered using https://zoom.us ?  We use it at [codementor.io](https://codementor.io/erikeidt) and it works pretty well.  One person runs the development environment, and then shares their screen. 
   As compared with some of the alternatives, like google hangouts, the remote person can also type and move the mouse.  It does audio & video as well.  Its also free for certain uses/scenarios.
Comments.UserDisplayName: Erik Eidt
Comments.ContentLicense: CC BY-SA 4.0
Comments.CreationDate: 2020-03-18T20:59:19.583Z
Comments.Text: @ErikEidt I hadn't.  At the moment, we are still forbidden from using anything with live video in my school district for liability purposes, but there has been talk of opening up Zoom because many other high schools are using it.  Also, you should post that as an answer!
Comments.UserDisplayName: Ben I.
Comments.ContentLicense: CC BY-SA 4.0
Comments.CreationDate: 2020-03-18T21:03:40.983Z
Comments.Text: You don't need to use the live video, fwiw..  I mentor regularly and I don't even have my camera hooked up.
Comments.UserDisplayName: Erik Eidt
Comments.ContentLicense: CC BY-SA 4.0
Comments.CreationDate: 2020-03-18T22:48:09.673Z
Comments.Text: I'm not up to speed on the rules of pair programming, so my concepts might be a bit off. Working on an answer, but need a bit more about the rules, for compliance purposes. The biggest being does "anything with live video" rule out sharing the IDE window live, or is it only regarding video of the person and other video, live or not, is acceptable?
Comments.UserDisplayName: Gypsy Spellweaver
Comments.ContentLicense: CC BY-SA 4.0
Comments.CreationDate: 2020-03-18T22:49:47.803Z
Comments.Text: Second question about requirements: does the solution need to be a package, or can it use a collection of apps, ie: one for chat, one for video feed, and one for code sharing, etc.?
Comments.UserDisplayName: Gypsy Spellweaver
Comments.ContentLicense: CC BY-SA 4.0
Comments.CreationDate: 2020-03-19T01:18:43.973Z
Comments.Text: @GypsySpellweaver Interesting point. I don't consider screen sharing to be live video (zoom has live screen sharing, live audio, and live video), but YMMV...
Comments.UserDisplayName: Erik Eidt
Comments.ContentLicense: CC BY-SA 4.0
Comments.CreationDate: 2020-03-19T02:15:46.520Z
Comments.Text: I wouldn't think of screen sharing as a problem. The fear is accidentally videoing a student in some way that they should not be videoed, so I don't think sharing a desktop or a window would be a problem, just webcams.  FWIW, it's not even 100% clear that student to student webcam meetings would even be countermanded, just student to staff.
Comments.UserDisplayName: Ben I.
Comments.ContentLicense: CC BY-SA 4.0
Comments.CreationDate: 2020-03-19T02:20:12.247Z
Comments.Text: @ErikEidt While not included in the question/tags, as irrelevant, the students in question are minors (mostly at least) and for their protection all kinds of restrictions may be imposed. One never knows.
Comments.UserDisplayName: Gypsy Spellweaver
Comments.ContentLicense: CC BY-SA 4.0
Comments.CreationDate: 2020-03-19T02:25:28.340Z
Comments.Text: @ErikEidt I would gladly take answers that I can't directly use, since I suspect that different people could use different answers, and many are facing this issue (broadly speaking) right now.
Comments.UserDisplayName: Ben I.
Comments.ContentLicense: CC BY-SA 4.0
Comments.CreationDate: 2020-03-19T20:04:28.423Z
Comments.Text: I refer you to my earlier answer on another question: the one about VNC, and gnu screen. I will also add Gnu emacs. But only in a safe virtual environment (as you can control the other persons account). Emacs allows two people to share an editor, edit the same code at the same time. I don't think I worked out how to see the other persons text cursor, so we went with Gnu screen (command line), and VNC full graphical desktop..
Comments.UserDisplayName: ctrl-alt-delor
Comments.ContentLicense: CC BY-SA 4.0
Comments.CreationDate: 2020-03-22T08:13:24.343Z
Comments.Text: Would VS Live Share be an option? It doesn't share the screen, only the code. VS Code has an audio system also, not sure about VS at the moment.
Comments.UserDisplayName: VisualMelon
Comments.ContentLicense: CC BY-SA 4.0
Comments.CreationDate: 2020-03-23T12:03:22.263Z
Comments.Text: @VisualMelon You should post that as an answer :)
Comments.UserDisplayName: Ben I.
Comments.ContentLicense: CC BY-SA 4.0
Comments.CreationDate: 2020-04-05T13:50:16.187Z
Comments.Text: @ErikEidt Just a quick alert, Zoom currently has a vulnerability. See [chat transcript](https://chat.stackexchange.com/rooms/59174/conversation/zoom-alert)
Comments.UserDisplayName: Gypsy Spellweaver
Tags: <pair-programming><distance-learning>
Title: Distributed Pair Programming in distance education
ThreadText: # Distributed Pair Programming in distance education
  
  (Asked by: username_0 on 2020-03-18)
  
  We've done pair programming for years with the rule of two kids, one screen, and the kids sitting next to each other. We have found this to be a tremendously valuable process.
  
  Now that all instruction is distance learning due to COVID-19, are there virtual solutions that would allow our students to simulate something like this?
  
  **Tags:** pair-programming, distance-learning
  
  > **Comments:**
  > **username_1**: Have you considered using https://zoom.us ?  We use it at [codementor.io](https://codementor.io/username_1) and it works pretty well.  One person runs the development environment, and then shares their screen.   As compared with some of the alternatives, like google hangouts, the remote person can also type and move the mouse.  It does audio & video as well.  Its also free for certain uses/scenarios.  
  > **username_0**: @username_1 I hadn't.  At the moment, we are still forbidden from using anything with live video in my school district for liability purposes, but there has been talk of opening up Zoom because many other high schools are using it.  Also, you should post that as an answer!  
  > **username_1**: You don't need to use the live video, fwiw..  I mentor regularly and I don't even have my camera hooked up.  
  > **username_2**: I'm not up to speed on the rules of pair programming, so my concepts might be a bit off. Working on an answer, but need a bit more about the rules, for compliance purposes. The biggest being does "anything with live video" rule out sharing the IDE window live, or is it only regarding video of the person and other video, live or not, is acceptable?  
  > **username_2**: Second question about requirements: does the solution need to be a package, or can it use a collection of apps, ie: one for chat, one for video feed, and one for code sharing, etc.?  
  > **username_1**: @username_2 Interesting point. I don't consider screen sharing to be live video (zoom has live screen sharing, live audio, and live video), but YMMV...  
  > **username_0**: I wouldn't think of screen sharing as a problem. The fear is accidentally videoing a student in some way that they should not be videoed, so I don't think sharing a desktop or a window would be a problem, just webcams.  FWIW, it's not even 100% clear that student to student webcam meetings would even be countermanded, just student to staff.  
  > **username_2**: @username_1 While not included in the question/tags, as irrelevant, the students in question are minors (mostly at least) and for their protection all kinds of restrictions may be imposed. One never knows.  
  > **username_0**: @username_1 I would gladly take answers that I can't directly use, since I suspect that different people could use different answers, and many are facing this issue (broadly speaking) right now.  
  > **username_3**: I refer you to my earlier answer on another question: the one about VNC, and gnu screen. I will also add Gnu emacs. But only in a safe virtual environment (as you can control the other persons account). Emacs allows two people to share an editor, edit the same code at the same time. I don't think I worked out how to see the other persons text cursor, so we went with Gnu screen (command line), and VNC full graphical desktop..  
  > **username_4**: Would VS Live Share be an option? It doesn't share the screen, only the code. VS Code has an audio system also, not sure about VS at the moment.  
  > **username_0**: @username_4 You should post that as an answer :)  
  > **username_2**: @username_1 Just a quick alert, Zoom currently has a vulnerability. See [chat transcript](https://chat.stackexchange.com/rooms/59174/conversation/zoom-alert)  
  
  ---
  
  ## 4 answers
  
  ### Answer by username_2 on 2020-03-19. Score: 3
  
  My suggestion would be to utilize seprate tools for elements of the process rather than try to find a packaged solution, or modify an existing tool which is 'not quite right' for the task.
  
  Quick summary is:
  
  * use Discord for communications, text and/or audio
    + Restricted channels for each pair to utilize while coding
    + Open channel for students to contact the instructor
  * use the GoLive feature of Discord for the "driver" to stream their active IDE to the "navigator" (GoLive will stream a "terminal" window, it does not have to be a game.)
  * use `git` to "lock in" the code between role switches with commits
  * use GPG keys for signing of commits and to authenticate the SSH pushes
  * use GitLab as the remote repository
  
  ## Use Discord for communications
  
  As the instructor:
  
  1. Create a Discord server
  2. Create a public text channel for the students to reach you in
  3. Create a public text channel for the students to share in (you can monitor, but don't communicate here)
  4. Create a *role* for each assigned student pair
  5. Create a private text channel for each *role* above
  6. Create a private audio channel for each *role* above
  7. Enable each *role* to send/read messages, or connect and use GoLive, in the *role*-specific text and voice channels
  8. As students join, however you get them to connect, assign them to the *role* which matches the assigned pairings
  
  As the owner of the server the instructor will be able to read the chat in all text channels, hear the conversation in any audio channel, and view any of the windows being streamed. Instructor preference and style take priority, but my suggestion is to limit any messages sent by the instructor to the designated channel. Moderator type actions can, and of course should, be taken in any channel. Going remote still leave "classroom discipline" in the instructor's hands.
  
  As the school term progresses, it's likely that pairs are reassigned frequently. Perhaps as often as each new project. Once a project is graded, the associated text channel could be reset, or removed.
  
  ## Use `git`
  
  While `git` may not be *The one **true** source control system*, it is a popular one. The command line use of it can be quite complicated, especially for advanced purposes. The basics of it, however, are quite manageable for students. GUI tools also exist, though I'm reluctant to endorse any one, or even recommend their use. With students learning to use `git` it is probably better for them to learn the CLI commands, which will work on any OS, and on any system with `git` installed. The GUI they learn might not work on the system they have to use later, for work or for advanced classes. The GUI probably won't work if they have to use SSH for any reason as well.
  
  Using `git`, as long as both students have access to the repo, allows for one to make changes, commit the results, and pass control to the other when they switch roles. As an extra benefit, since the current "navigator" will have the last committed version locally, they can scan through the file(s) to review other parts while directing the "driver". Ensuring that identifier names and parameters are used correctly, for example, without disturbing the "driver" with those details, allowing the driver to concentrate on the section of code being changed.
  
  As a benefit to the students, they'll have the ability to unroll changes that were leading down a dead-end. As a benefit to the instructor, each commit will be blamed to the student driving. Additionally, by following the diffs, it's likely that when the team gets lost in the weeds, the instructor can see what thinking started the problem, and help them to see the way out.
  
  ## Use GPG keys
  
  The "remote" aspect of this is challenging for instructors to "watch" the students work. Having to worry about who is doing the work and who is not only adds to the work load. Requiring that the students GPG-sign their commits can help with that some. Not only will the repository assign the updates to the user, it will also verify that the user claiming the updates is the same one who signed them. There is no encryption involved, just a signing of the commit to prove who made it. Using it, however, might require the students to install GnuPG on their systems. Encouraging them to do so shouldn't cause any issue, and it can be a good habit to develop for later as well.
  
  The process of setting up a key for use with the `git` program, and for connecting to the remote repository is fairly simple. Even from the command line.
  
  1. Generate the key pair to use. The key pair needs to have both singing and authorization capabilities.
  
  ```
  username_2@username_2:~> gpg --quick-generate-key "Student Name <email.name@some-school.edu>" future-default auth,sign
  We need to generate a lot of random bytes. It is a good idea to perform
  some other action (type on the keyboard, move the mouse, utilize the
  disks) during the prime generation; this gives the random number
  generator a better chance to gain enough entropy.
  gpg: key A822359C643A77A4 marked as ultimately trusted
  gpg: revocation certificate stored as '/home/username_2/.gnupg/openpgp-revocs.d/11716FF672B9DD368C174F26A822359C643A77A4.rev'
  public and secret key created and signed.
  
  pub   ed25519/A822359C643A77A4 2020-03-19 [SCA] [expires: 2022-03-19]
      Key fingerprint = 1171 6FF6 72B9 DD36 8C17  4F26 A822 359C 643A 77A4
      Keygrip = 92F62A329D3CBBBE64BFA8DABC6F4348623AB256
  uid                            Student Name <email.name@some-school.edu>
  
  ```
  
  2. The ASCII version of the public key will be needed when setting up the repository.
     This block will be copy-pasted to the repository within the user's account settings.
  
  ```
  username_2@username_2:~> gpg --armor --export A822359C643A77A4
  -----BEGIN PGP PUBLIC KEY BLOCK-----
  
  mDMEXnMHZxYJKwYBBAHaRw8BAQdAjh6qOGnp5b0GTNZEHL4wIrIljwxLlxfU8/F5
  l8TZVNC0KVN0dWRlbnQgTmFtZSA8ZW1haWwubmFtZUBzb21lLXNjaG9vbC5lZHU+
  iJ0EExYKAEUWIQQRcW/2crndNowXTyaoIjWcZDp3pAUCXnMHZwIbIwUJA8JnAAsL
  CQ0IDAcLCgMBBAYVCgkICwMFFgMBAgACHgECF4AACgkQqCI1nGQ6d6RXEAD/Rdhz
  kh+gNvnO367JYqdoIwFiIsW4a2mq3d4nqNE6migBAM3m8cMO2Ww2u5+O7l8P4GuI
  EMTlK2WWckAEJUGS1pMO
  =6LSb
  -----END PGP PUBLIC KEY BLOCK-----
  
  ```
  
  3. The public key needs to be saved in SSH format.
  
  ```
  username_2@username_2:~> gpg --output id_ed25519.pub --export-ssh-key email.name@some-school.edu
  
  ```
  
  4. The public key will be needed when setting up the repository on GitLab.
     The last line is what will be copy-pasted in the settings of the repository for the SSH key.
  
  ```
  username_2@username_2:~> cat id_ed25519.pub
  ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAII4eqjhp6eW9BkzWRBy+MCKyJY8MS5cX1PPxeZfE2VTQ openpgp:0x643A77A4
  
  ```
  
  5. the `git` program needs to be set to always gpg-sign commits and told which key to use
  
  ```
  git config --global commit.gpgsign "true"
  git config --global user.signingkey "A822359C643A77A4"
  
  ```
  
  ## Use GitLab as the remote repository
  
  Usually GitHub vs GitLab is more about personal preference than any project-based requirements. The granularity of permissions in GitLab is better than GitHub, allowing the instructor to grant access to the assignment repos on a per-user basis. GitLab allows for unlimited private repositories without having to create a paid account. Let's face it, as a rule educators don't have the spare funds to support enterprise level tooling. GitLabs give for free what GitHub will charge for. As it is student work, private repos seems more appropriate on two grounds. First, normally student assignments are not available to the general public. Even more so when dealing with under-age students. Second, by having private repos, with only the pair of students working on it being granted access, the ability to copy one team's work by another team is greatly reduced.
  
  Three additional factors available from GitLab which might be useful are: 1) Discord Notifications, 2) their Continuous Integration (CI) pipeline, and 3) the ability to install a local, or self-hosted, GitLab for greater security. Depending on the language being use, the CI pipeline might help in keeping variations in build environments between student systems, or between their system and the instructor's system, from hiding or creating errors.
  
  ## Tidbits and Notes
  
  One possible downside to Discord is that it *can* also be used for video calls. That, however, is a something which is available through the "friends" section rather than in the "server" you would be responsible for, so it shouldn't count against you, or the application.
  
  A bonus for Discord is that the odds are high that most of the students already have it installed, and know how to use it. They probably know how to use it better than the instructor would.
  
  For the current crisis (COVID-19) Discord has increased the size of GoLive streams to 50. That shouldn't matter unless it's decided to us the GoLive feature for the instructor to do demonstrations, which is also a possibility.
  
  If the students have an assigned email account from the school, it is probably a good idea to require that such email be the one associated with the GPG keys and the accounts on GitLab. Official required communications should be done by email using that address as well. Assignment instructions, due dates, grades, etc., rather in the untracked space of Discord.
  
  To "invite" the students to the Discord server, create short-lived, single-use invites for each student, and send that in an email to them rather than a general invited for the class.
  
  For most Linux systems, `git` is a simple install, directly from the default software repositories. For Windows it takes a bit more work. A guide, which seems to be pretty good, is [How to install and use Git on Windows](https://www.computerhope.com/issues/ch001927.htm).
  
  An advantage, and possible disadvantage of using the GoLive option is that each student can have their own version of the IDE, customized to their preferences. It's even possible they could use a different IDE than they would in class, and different from what their partner is using.
  
  The potential problem with this is that they could become lost in the IDE and the instructor, having never used *that one* might not be able to help.
  
  An unplanned benefit could be that new insights into student preferences, including IDE choices, can be obtained by noticing which IDE students gravitate towards, and how they use them. Once classroom instruction is able to resume, a change of IDE for in-class use might be in order.
  
  The 24/7 availability of the tools can get the students into the habit of "calling" the instructor an anytime, without thinking that there are other things to do, or classes to work with. Setting a time for "class" where you will be available on the server for direct contact, perhaps during the same time-span as class was held when it could be held. To avoid the appearance of always being available it might be worth creating a different server for each class, keeping your "office hours" on each server in turn.
  
  > **Comments:**
  > **username_5**: Switching between driver and navigator should be simple, quick, and seamless. Is it with this solution?  
  > **username_0**: I am, as I *often* am, blown away by your post. Thank you!  
  > **username_2**: @username_5 It should be seamless. Driver does save, commit, push. New driver does pull, open (or refresh) and starts editing  
  
  ---
  
  ### Answer by username_6 on 2020-03-21. Score: 2
  
  I've been experimenting with AWS Cloud9 with a view to remote pair-programming (at the professional level). Also, as a means of (vocational level) coaching of young professionals currently working-from-home. Might it meet your needs?
  
  Also, Amazon have various educational tie-ups, which your school/system might investigate.
  
  Disclaimers: AWS is subject to US 'export controls'; some don't like using such service-providers in principle; I have no link to AWS other than as a user.
  
  Regards =dn
  
  
  ---
  
  ### Answer by username_5 on 2020-03-19. Score: 1
  
  In the past I've successfully used XPairtise for Eclipse. The Eclipse marketplace shows this and a couple of others: <https://marketplace.eclipse.org/category/free-tagging/pair-programming>
  
  A separate voice or text channel might be good to use with it.
  
  But you want something with a fast and seamless switch between driver and navigator and also integration with the testing system. Eclipse with a plugin gives you that. The switch of roles should be as quick as passing the keyboard from one person to the other in co-located programming. Here it might be "click a button to switch roles."
  
  Note that XPairtise hasn't been updated for a while and the others listed are newer. I haven't tried them.
  
  A web search for "distributed pair programming" will probably give more information.
  
  > **Comments:**
  > **username_0**: I can't believe there are plugins that do this.  How simple!  I use Eclipse, but most of my students use IntelliJ, but I am sure there are similar plugins there as well.  Fantastic!  
  > **username_5**: An advantage of Eclipse is that it is agnostic about the language you program in, with lots of support for other languages than Java. I don't know if that is also true of IntelliJ, but if not then learning Eclipse leverages to many other things. It can even be used for non-programming tasks. Students shouldn't need to learn an entirely different tool set for each course they take. The Eclipse Marketplace has a huge number of resources.  
  > **username_2**: I'd guess that without a real-time communication channel, independent of the code, pair programming is reduced to relay programming. The navigator has to tell the driver what to do in the moment, not as a road map to follow until it's their turn. Text chat is workable, while voice chat reduces the distraction of having to "notice" that the partner has said something, and resembles the in-person pair programming more fully. Soros includes a chat window as part of the plugin (from the screen shots anyway.)  
  > **username_5**: @username_2 XPairtise (maybe others) provide a text based channel. I can't remember whether there is a second cursor the navigator controls. But the navigator isn't a puppet master. They comment only as necessary. The point out potential design flaws, suggest spelling changes for code clarity and such. The driver has complete control and isn't overridden by the navigator. The driver takes a microscopic view of the code, the navigator a macroscopic view. This difference of views is natural and has been observed. The power is in the integration of the two views.  
  > **username_5**: But a higher bandwidth channel (voice...) is certainly helpful.  
  
  ---
  
  ### Answer by username_7 on 2020-03-26. Score: 1
  
  Keep it simple and integrate into tools that your school is already using as much as possible.
  
  For example, my university is using MS Teams (which [may currently be free for everyone](https://products.office.com/en-us/microsoft-teams/remote-learning)). To do pair programming, each pair of students sets up a call with each other and one person shares their IDE window (we use Thonny). The other one then requests control, so either person can play either role (driver or navigator).
  
  (Edits welcome for corresponding info about Zoom.)
  
  
  ---
  
  