This year the celebration it is (was for me!) going to be even larger as Research Software Allieance’s International Research Software Conference is co-located and happening just before RSECon. Two conferences celebrating Research Software in one week. It sounds like a dream.

And for me, it will be still a dream…

Both conferences are happening at the University of Sheffield, a place I keep in my heart as it was were I taught my first SunPy and Astropy workshop and where many of the Sunpy early developers were based. However, the management at Sheffield has been playing dirty games. After staff went on 16 days of strike last year, and therefore classes were missed. The management of the university decided “double deducting” to those who refused to deliver these missed classes, for which they haven’t already been paid.

In the light of these circumstances, University and College Union (UCU) has called their members to boycott any activity involved with the university, such as participating on conferences being held there.

In short, I’m not celebrating in #Sheffield this week.

It’s hard because I know Sheffield wont even notice that I won’t be there. And I know that RSECon and IRSC have both evaluated the financial impact for our communities withdrawing and therefore loosing a large deposit. But, though I understand that our financial impact to the university is small for them but large to us, I also believe our personal and academic community impact is more important. This is why I withdrew the sessions I was taken part on. By writing here I wish my words reach to other RSEs and maybe Sheffield’s future students and staff, so they know what type of values are followed by their management.

To all staff affected: ✊ Solidarity!

The steps I’m going to show may be very specific to my university, but I’m sure you have got some similar system at your institution/school.

What do we need?

• Anki for the memorisation bit. You can use it on your desktop or on your phone. Anki allows you to synchronise between devices but you’ll need to be careful whether this is through a public server, as you don’t want to leak your students names and pictures to the wild. If you want synchronising between various devices, you can run your own sync server on your desktop. If you are going to use a single device, then you don’t need to worry.
  • You will need anki desktop client for the step of creating cards.
  • And an Anki addon: Media Import 2
• Students photos named with their names.

Then opening the media import 2 menu in anki, and following the indications as explained on their website, you can get cards for it.

This is all easy and good… however, the platform at our university doesn’t provide the photos with the names already, and having to do that manually would be a pain with more than 10 students. So, what would you need?

What do we need? (in UCL)

• A browser, I’m using Firefox
• Two browser addons:
  • DownThemAll! - to automate the downloading the images.
  • GreaseMonkey (or similar) - to do some manipulation so the images can be downloaded with the names we want.

Hands on (UCL)

Once you access portico, get to your module list with the pictures of your students, then when you try to download them using downthemall you discover that the images contain no file names, and what’s worse, the title and description tags say something like “This student has no photograph” 😓.

We can’t change the file names directly, therefore we need to change the title or the description, which thankfully downthemall can use them as mask to save the files when downloaded (as shown in the bottom of the above image where it’s asking to save them using the title of each image).

Here’s where greasemonkey comes in. Greasemonkey allows us to modify websites using a bit of javascript. We are going to write a small script that when loading the site modifies the alt attribute for each photo using the names shown below them. This is how the website looks:

And this is the Greasemonkey script to do so:

// ==UserScript==
// @name     portico-students-names
// @version  1
// @grant    none
// @include  https://<url-to-the-page-where-photos-are>/*
// ==/UserScript==


function modify_alt(){
  var students = document.getElementsByClassName("sv-panel-body");
for (item in students){
  students[item].children[0].alt = students[item].children[4].innerText;
	}
}
modify_alt();

This script defines a function modify_alt which then is called at the end of the script. The function gets first all the students cards (which in our case are under a div using a class named sv-panel-body). Then iterates over each of the cards and then adds the alt attribute the text of where the name is.

Looking at the snippet of one of those cards in html,

<div class="sv-panel-body">
  <img alt="This student has no photograph" align="left" width="auto"
       height="160" src="path/to/image">
  <p align="right"><span class="glyphicon glyphicon-home"></span> Filming</p>
  <p align="right">19141104/2<br><span title="MArt Filming">UMSFILG18</span><br>Year 4<br>Enrolled<br><span>Full-Time<sup></sup><br><br></span></p><br>
  <strong>Hedy</strong>
</div>

we can see that the children values of the sv-panel-body are 4, the <img>, the <p> with the degree, the <p> with the student information and the <strong> that contains the name of the student. That’s how we extract the student name and inserted in the alt attribute that Downthemall will use to download the images.

Once activated the greasemonkey script and loading the page, when we open Downthemall we see that the title column (and the description) contains the names of the students as we wanted:

Once you’ve downloaded the images, you can import them with Anki’s Media Import 2 and produce flashcards with the student photo and their name. You can create them as double cards if you want to be prompted with the photo and the name and you have to guess the other.

I’ve started to use mu4e a while ago, motivated by the instructions shared on M-x Research when Martin Richter showed us how to do it.

One thing I’d like to have is a send-later feature as outlook and gmail allows you to do so. So I can schedule an email to be sent on a particular day. Unfortunately I’ve not found a way to do so yet that works for me. I’ve been told that gnus has an option to do so, but you’ll need a computer switched on waiting that the time comes. I have some ideas on how that could be implemented for Outlook, but I’ve not come around that yet.

An alternative that I’d be happy with is to be able to queue my email. Either because I don’t want to send emails later in the evening, or just because I’m in a place without internet. mu4e has the machinery to queue emails as it’s shown in their documentation. However, it took a while for me to realise what I was missing. So, hopefully my lines below helps to others and also people can comment on my elisp so I can improve.

mu4e documentation seems straight forward, you need only two variables being set (smtpmail-queue-mail and smtpmail-queue-dir) and that the queue directory actually exists. For much I tried, this was not working, the emails were either sent, or erroing when I was disconnected from the net. Reading through the code I figured out that the issue was that I hadn’t configured my email using smtpmail emacs library, but instead msmtp program. I believe the reason is because the oauth authentication workflow I need for my university requires that I use oauth2ms (please, feel free to correct me if I’m wrong!).

Once I new the cause was there I started thinking on how I could queue it. This brought me to search those two terms: msmtp and queue. And that pointed me to this particular bit of the source code of msmtp. Some scripts untouched from 17 years ago (if it works, why touch it, right?). I started to dive into them, thinking how I could use them, then I realised that on the nav bar on the left said emacs, and I got exited thinking that the solution may have been there already… but no, it was not. However, that distraction helped me to find msmtpq… which I clicked on it thinking it was what I was trying to digest before. But it was not!

msmtpq provides a layer on top of msmtp that before sending any email checks whether you’ve got a live connection. This seemed promising!

So, what did I do? I started messing up with my emacs config code, and look into what mu4e was doing. This is what I come up with.

First, I needed to put the msmtpq script on my path. In my Arch distro I had to do:

cd ~/.local/bin
ln -s /usr/share/doc/msmtp/msmtpq/msmtpq .
ln -s /usr/share/doc/msmtp/msmtpq/msmtp-queue .

Then in emacs I had a variable that defines what the sendmail program is

(setq sendmail-program  (executable-find "msmtp"))

and I wanted to change it to the msmtpq when I want to queue the email. So I crated a function that depending whether I’m in queue or direct mode (i.e., whether smtpmail-queue-mail is true or not) tells what executable to use:

(defun dps/queue-or-not ()
  (if smtpmail-queue-mail
      ;; need to set some system variables
      ;; EMAIL_CONN_TEST='q'
      ;; EMAIL_QUEUE_QUIET=1 ;; to keep it quiet
      (progn (setenv "EMAIL_QUEUE_QUIET" "1")
	     (setenv "EMAIL_CONN_TEST" "q")
	     (executable-find "msmtpq")
	     )
    (executable-find "msmtp")
    ))

Originally, I had set that EMAIL_CON_TEST system variable to 'x', wrongly thinking that it meant that it was not going to be sent, but it actually means to don’t check for internet connection. Since I wanted to force it to queue even if I had internet, I introduced a new parameter into msmtpq.

316,317d315
<   elif [ "$EMAIL_CONN_TEST" = 'q' ] ; then                     # force it to queue
<     return 1

I’ve opened a PR to msmtp to include that option, in case this becomes useful for more people.

Note to my future self:
In a future refactoring, probably all I need on the function above is to set that variable from 'x' to 'q', and always use msmtpq.

Once I had that function, I could define the sendmail-program to read from it. So, I tried something like:

(setq sendmail-program  'dps/queue-or-not)

And other variants of the above (you know with #, with ,, with all of them….), but that was not working because where that variable was used was expecting the path, not a function to execute. So I had to approach the problem in a different way.

My first approach was to set that variable when I toggle the sending mode on mu4e, and mu4e has that encapsulated into the mu4e--main-toggle-mail-sending-mode function. So, I can copy it and modified, and that’s what I did:

(defun mu4e--main-toggle-mail-sending-mode ()
  "Toggle sending mail mode, either queued or direct."
  (interactive)
  (unless (file-directory-p smtpmail-queue-dir)
    (mu4e-error "`smtpmail-queue-dir' does not exist"))
  (setq smtpmail-queue-mail (not smtpmail-queue-mail))
  (mu4e-message
   (concat "Outgoing mail will now be "
           (if smtpmail-queue-mail "queued" "sent directly")))
  (unless (or (eq mu4e-split-view 'single-window)
              (not (buffer-live-p (get-buffer mu4e-main-buffer-name))))
    (setq sendmail-program (dps/queue-or-not))
    (mu4e--main-redraw)))

Inserting that setq line in the second last line.

Perfect, that works! I can toggle the email on the dashboard, and it queues or send the email as I need.

Next I wanted to display how many emails were on the queue… and for that I had to rewrite another function, this time mu4e--main-queue-size function. And this is how that looks now:

(defun mu4e--main-queue-size ()
  (length (directory-files "~/.msmtp.queue" nil "msmtp"))
  )

Which essentially counts how many .msmtp files are in the queue directory.

And finally, I needed to update flushing the queue command. mu4e uses smtpmail-send-queued-mail, but I’m not using that anywhere, so I could rewrite as:

(defun smtpmail-send-queued-mail ()
  (interactive)
  (setenv "EMAIL_CONN_TEST" "x")
  (shell-command (concat (executable-find "msmtp-queue") " -r &") "*msmstp-queue*")
  )

And that’s all I needed. I’m not too happy on copy-paste and changing functions, but it works for now. Making me very happy to see that when I change the email mode the interface reflects that and emails get queued or flushed as I want.

…

Till I went to demonstrate it live yesterday on the Emacs London meetup. There I told them why I did and how so I could get some feedback. And I did.

First, why it was not working when I show it to them? It took me a while to figure it out, and toggle-debug-on-error was not helpful. However, I found out that the emails were not being queued because emacs couldn’t find msmtpq. This happened because I’m starting emacs as a service, and the $PATH in that environment doesn’t includes ~/.local/bin. Though surprisingly, if I do M-! echo $PATH it does. So I solved it by creating a copy of emacs.service into my ~/.config/systemd/user/ where I added:

Environment="PATH=~/.local/bin:/usr/local/bin:/usr/bin"

and now it works.

Additionally, I’ve got some “advice” on how to modify the large function I had to copy from mu4e to define the program (and variables) depending of the mode.

So, this

(defun mu4e--main-toggle-mail-sending-mode ()
  "Toggle sending mail mode, either queued or direct."
  (interactive)
  (unless (file-directory-p smtpmail-queue-dir)
    (mu4e-error "`smtpmail-queue-dir' does not exist"))
  (setq smtpmail-queue-mail (not smtpmail-queue-mail))
  (mu4e-message
   (concat "Outgoing mail will now be "
           (if smtpmail-queue-mail "queued" "sent directly")))
  (unless (or (eq mu4e-split-view 'single-window)
              (not (buffer-live-p (get-buffer mu4e-main-buffer-name))))
    (setq sendmail-program (dps/queue-or-not))
    (mu4e--main-redraw)))

become

(defun dps/mu4e-toggle-mail (orig-func &rest args)
  (setq sendmail-program (dps/queue-or-not))
  (apply orig-func args)
)

(advice-add #'mu4e--main-toggle-mail-sending-mode :around
	    #'dps/mu4e-toggle-mail)

Which is a lot nicer and I don’t need to keep an eye on what’s maintained.

All together

At the end I followed my suggestion above and have just refactor it a bit more, so this is what I’ve got.

I need that smtpmail-queue-dir variable exists pointing to a mu directory created as de queuing docs suggest, even though, the emails are not stored there. And I’m going to keep it that for a bit till I have more time to play.

I’m starting on queueing mode by default and this is how all fits together (don’t forget to modify msmtpq to include the q as I said above first):

(require 'smtpmail)

(setenv "EMAIL_QUEUE_QUIET" "1")  ;; to keep msmtpq quiet
(setenv "EMAIL_CONN_TEST" "q") ;; queing by default
(setq smtpmail-queue-mail t  ;; start in queuing mode
      smtpmail-queue-dir   "~/Mail/queue/cur" ;; though we are not using it mu4e needs it to be able to toggle
      sendmail-program (executable-find "msmtpq")
      send-mail-function 'message-send-mail-with-sendmail
)

(defun dps/queue-or-not ()
  (if smtpmail-queue-mail
      (setenv "EMAIL_CONN_TEST" "q") ;; queue
      (setenv "EMAIL_CONN_TEST" "x") ;; try to send (will queue if fails)
  )
)

(defun dps/mu4e-toggle-mail (orig-func &rest args)
  (apply orig-func args) 
  (dps/queue-or-not) ;; evaluated after the toggle so we know the smtpmail-queue-mail value
)

(advice-add #'mu4e--main-toggle-mail-sending-mode :around
	    #'dps/mu4e-toggle-mail)

;; rewrite of mu4e--main-queue-size
(defun mu4e--main-queue-size ()
  (length (directory-files "~/.msmtp.queue" nil "msmtp"))
)

;; rewrite of smtpmail-send-queued-mail
(defun smtpmail-send-queued-mail ()
  (interactive)
  (let ((sys_email_conn (getenv "EMAIL_CONN_TEST"))) ;; temp variable to restore the value of varialbe
	   (setenv "EMAIL_CONN_TEST" "x")
       (shell-command (concat (executable-find "msmtp-queue") " -r &") "*msmstp-queue*")
	   (setenv "EMAIL_CONN_TEST" sys_email_conn)
  )
)

Any improvements you can think of is highly appreciated! Tell me on mastodon or through an issue on GitHub.

Thanks to the Emacs London meetup, in particular to Przemek and Eric.

I’m off till D Month. I’ll be come back to you as soon as I can after that day.

That kind of message doesn’t help anyone. I’m giving a false hope that I’ll reach to that email and when I’m back in the office I get overwhelmed with the large amount of emails I’ve collected while I was away.

This time, and induced by reading “A world without email” book by Cal Newport I had first decided to change the OoO message to:

I’m off till D Month. Your email has been deleted, send it again when I’ve returned.

However, while discussing the plans with a colleague who made me think on the pressure that this may put on others, I considered a different approach. This was my OoO for the last three weeks:

Hi there! I’m away enjoying my holidays (till the 20th) or at a workshop (20th-24th)!

TL;DR: Your email is safe – eventually, I’ll come back to you. You need something urgently – jump to the end of the email.

I was planning to delete any incoming email while I was away, and let you know about such actions. But a good friend has made me rethink this course of action, as doing, so I’d be putting the burden on you! What am I doing instead? Glad you’ve asked!! I’m archiving all the emails received during my time off under a special folder. When I’m back, a little program will be pulling two random emails a day into my inbox, and I commit to answer these. How long it will pass before I answer you will depend on luck and the number of emails I may have received. By doing so I’ll have a better start and don’t get overwhelmed by a large amount of things to pay attention to.

Something urgent about […]

Have a great time (I’ll make sure I’ll be doing so)!! David

PS: You can trick this system (and this is allowed!) by sending me a reply to the original email when I’m back. This way, the old email will resurface again!

I’ve received various positive comments from people who received this OoO and my Inbox is empty. So, I suppose this approach has worked well… at least till now. I checked the number of emails I’ve got in that separate folder this morning and it would take me more than 9 months to go through them. Let’s see who are the lucky ones that get replied this month.

What’s the “technical side” of this? I first attempted to do something very fancy with MS Power Automate, which allows to grab emails from your account and do a set of things. However, I got stuck with the random selection. Their email tool they have only take 25 emails and that would only benefit at those who wrote closer to my return. I also tried to come up with some spreadsheet formulae, but that also failed.

First of all I created a rule on the outlook web client. I’ve set it so that all the emails with me in the “To” field were going to be archived in the OnHolidays folder. The rest of emails are redirected to OnHolidaysSecondary. I’ll be drawing random emails from the primary folder till is empty, then go to the Secondary (which it should be less important things - I think!)

At the end, I went for a simple approach with the tools I’m more familiar: emacs and unix tools. I’m reading my email there, so why not do the random selection from there too? Using org-mode and the mu command I come up with the following:

mu find -u maildir:'/OnHolidays' -f "i l" | sort | uniq |  awk '{print rand()*1000000, $1, $2}' | sort | head -n 2 | awk '{print  "mu4e:msgid:"$2}'

The result of that looks something like:

mu4e:msgid:VI1PR01MB5135E9E1D4A1C701E11F182FC0A39@VI1PR01MB5135.eurprd01.prod.exchangelabs.com
mu4e:msgid:AM6PR0102MB314123DDE920ACBFA727172BADA39@AM6PR0102MB3141.eurprd01.prod.exchangelabs.com

which in emacs are clickable links to that particular email on my mu4e views.

I hope this is helpful

One of our rights is that we don’t need to inform our employer (or any one) our intentions of taking strike action before we do it, only after we have done it. That’s a way to avoid that the university reschedule things knowing before hand that you are not going to be working, reducing, therefore, the impact of the strike action.

I, and most of the people I know, set an out of office auto-replies on our email during the strike period. So, when we get emails, they get a nice message back from us telling them that we are on strike and use that opportunity to tell them why we do so. Making that some kind of digital picket line.

However, the default mechanism for out-of-office auto-replies has two problems:

1. The out-of-office email are only sent once to the sender during the period of time booked. So, if you set a 3-day period when you are taking strike action and the same person emails you everyday, that “sender” will only receive one auto-reply. This makes sense when you go for holidays and you say in your email when you will be back.

2. At least on MS systems, all the platforms (calendar, teams, etc…) will show the dates that you are set out-of-office.

These two problems might me think about a work around to email back to every email I get from the same sender (they are giving me more work) and to don’t disclose the time I’m going to be on strike.

My first approach was to set the out of office manually at the end of the day for the next day. This solve partially both problems, if someone emails me one email per day they get one auto response and they only become aware I’m not available for a meeting just on the day I’m taking the strike action.

However, it requires me every day to log into the system and enable it (when I may know how many days I’m taking action).

Automation to the rescue!

There’s a tool that comes with the full Office365 that allows you to create workflows that could work for this. The tool is call power automate, and you can access through the candy-box icon in the top left corner of any of the office365 pages. With this tool I’ve created a workflow that does the following, checks the date of each email I’ve received, if the dates matches with any of the dates in a spreadsheet, then it will send a reply (with a message I’ve also set in the spreadsheet).

Let’s see how to do it.

First thing we will do is to create a spreadsheet on one drive. That spreadsheet will contain a table with two columns: date and message (as shown in Figure 1).

Figure 1.

To create it as a table, select the columns, go to the insert menu and click on table. Be as original as you> want on the messages column. As Excel is not as good as to write long text, I suggest we write it somewhere else and then copy&paste it in the right cell. Otherwise, if we want to create a new line on an excel cell press alt+enter.

Once we’ve got the spreadsheet ready, we can proceed to create the power automate flow.

Open power automate from the candy-box menu and select the create button as shown in the Figure 2. If the tool doesn’t appear in that list, click on the “All apps” button and search it on the list shown.

Figure 2.

We are going to start from a blank automated cloud flow (Figure 3).

Figure 3.

Then we have to provide a name to our flow and its trigger. The name is only important for us to differentiate this from other flows we may create. Let’s call it “OoO during Strikes”. The trigger is the action that will kick the flow, in this case it’s the arrival of a new email. Type “email arrives” and the list will be filtered. We want to choose “When a new email arrives (V3)” as shown in the Figure 4.

Figure 4.

We click create and we have the start of our flow created.

This trigger allows us to choose which folder to track for emails arriving and some other options to filter such as the sender, to who was sent (e.g., if you want to only reply the ones that included you - or any other address - in the To or CC field, etc.). For now, we will only leave it as it comes by default.

Figure 5.

And click at the bottom to create a new step.

Now we will create an “action” that will extract a row from the excel spreadsheet we created before.

Choose Excel Online (Business) from the menu shown. Then in the following menu choose: “Get a row”.

In the “Get a row” dialogue, fill the parameters from the drop-down menus (the file name, the table, …). As shown in the figure. The “key value” field doesn’t come from a drop down, we need to write an expression down.

The expression to write is the following:

div(sub(ticks(triggerBody()?['receivedDateTime']), ticks('1899-12-30T00:00:00')), 864000000000)

This expression is converting the time from the email to the value that excel keeps dates in (essentially the number of days from December 30th, 1899).

With this, the “get a row” step will look into the file and the table we linked it too. Search the “key value” into the “key column”, and if it matches it will return that row from excel. We are using that now to compose our email to send back to the sender.

Let’s now create a new step. Here we choose “office 365 Outlook”, and “Send an email (V2)” as an action.

In the send-email dialogue we need to add “dynamic content”. There we can choose “From” field from the step below for the “To” field (i.e., send an email to sent it to us). For the subject we can also use the dynamic content to take the subject from the email we received and add any other decoration we want.

Finally, for the body, we will select the message column from the row we extracted in the step below. We can also add any other text in that box that will be common to all the days.

And that’s all! Click save, go back clicking the back arrow in the workflow top-bar (as shown below),

Make sure you turn it ON

And your email will be sending back emails to everyone who is writing to you.

To test it, we send ourselves and email and wait for the response. You can also see whether the flow is working or failing at the bottom of the page.

Now that we’ve done this… how do you think we could only send replies to the people in our university? For that we would need to create an intermediate step that creates a condition and checks whether the email ends by our university domain. If does so, then we proceed send the email, otherwise, send another general email.

Update: Check the next post to see how to include that condition.

We are starting from the flow that we created yesterday - so, if you haven’t done it yet, then start there. I’ll wait for you here.

Our previous power automate wokflow looked like this:

Now, we want to introduce a condition before sending these “personalised” replies only to senders from a particular domain, for example, youruniversity.ac.uk. In programming this is call control flow, in particular the conditional expression.

IF some conditions happens 
  THEN do x 
  ELSE do y

So, in our case this could be as

IF the email of the sender ends by `youruniversity.ac.uk`
  THEN send a reply
  ELSE do nothing

Let’s try to code this into our flow. First we need to think where we want to include it. Certainly we want it after the receive email box (the trigger of the flow) and before the “send email” action. We have two options, just after the email is received, or after the excel spreadsheet is loaded. Since the spreadsheet only contains the messages for when we want to send the reply, then it makes sense to make it before that. However, if we were to also automate the responses to external people, then we would want it after the row from the excel file is extracted.

When editing the flow, we can add a new step by clicking in the button at the bottom, or by clicking the plus symbol that appears when hovering in the connectors between the steps, as shown by this image:

We are going to create a condition action before getting the excel row. Choose add an action, and from the menu, choose Control. Inside the Control menu, pick condition.

The flow should look like:

And by dragging and dropping the excel and send email actions into the “yes” box, should then look like this:

We’ve got so far the skeleton of what we want to happen.

1. Trigger the flow when an email is received
2. IF <condition to create> happens
     THEN
        - extract the row for today
        - send a reply with the personalised message
     ELSE
        - do nothing

What we are missing is to set the condition. Remember, we want to only reply emails that comes from our own institution. Therefore, we need to look up the address of the sender and check if the end of the email is like youruniversity.ac.uk.

To do this step, we need to fill the three fields under the condition action. The first one is the value we want to compare. Clicking there you’ll see all the dynamic content generated from the previous action, and between these the “From” field - i.e., the email of the sender. In the second field we are going to set the condition. From all the options there, the simplest one for our needs is “ends with” and the last field we set the pattern we want the address of the sender to match. youruniversity.ac.uk. At the end, it should look like:

And that’s it! Now only the emails from a sender with a domain as specified in the condition will get through the “If yes” branch and get a reply.

One more thing! Remember to turn the workflow off when you don’t want to process your incoming email. You won’t be sending replies if there’s not a date matched on the spreadsheet, but we probably won’t like to have some machine somewhere in the world running these workflows once and again to fail all the times.

We’ve started a new month in this year (yeah 2022 already) and I’ve been yesterday and today wishing x2 happy new year (i.e., for 2021 and 2022) to so many colleagues I’ve not seen since we left the offices. So, Happy new years to you too!!

I’ve took over the “organisation” of the M-x Research group - an emacs group for people working on research projects. We’ve planned some activities for this year, and one of them was making February a functional month - i.e., to practice some elisp by our own solving some problems and share it with the group for feedback and encouragement. Unfortunately, I don’t think I did a good job advertising this challenge as I think I’ve been the only one trying to do it, and this February had a lot of strikes in UK universities, making it harder for people to engage with volunteering activities.

Nevertheless, I managed to do some of it! In average I’ve done 1 problem every two days! (and I’ll try to continue learning on March). Here I try to summarise how has been my learning voyage so far.

Learning elisp

I’ve been an emacs user since early 2000s. I still remember the first time I saw the emacs window and how confused I was with the word *buffers*. I only learnt things here and there from a printed copy of the emacs manual that was in the student’s computer room at my uni. Over the years I learnt that the configuration of the editor was managed by some weird language that used a lot of parenthesis and without knowing much about it and via copy&paste I got to set up things somehow right for me. It hasn’t been till two years ago that I started to consider learning that magic language. I have tried without really progressing much learning lisp from

• Structure and Interpretation of Computer Programs, via reading the book and watching the classes from 1986; and
• Land of Lisp book.

I didn’t really stick to any of these… other things happened and I didn’t progress much.

This year, however, it’s been a bit different! Our first event of M-x Research was an introduction to (e)lisp: Functional programming: an (Emacs) Lisp view 1/n (slides) by Jens Jensen. That was on the first of February and I had already “decided” that February was going to be a functional month.

From what I learnt that day I set the goal to solve all the exercism problems on the elisp track.

exercism is an online platform that contains some programming problems to be solved directly on the website (similar to codewars). Once you submit your solution it allows you to see how others have solved the same problem.

There are 28 exercises for elisp, and I thought it would be great if I could do one a day. It turned out I have only manged to complete 14 of them, but I’m so so so happy of my progress!

One of the things I’m more impressed with - and I don’t know whether that’s a good practice on functional languages yet - is that I’ve not created any variable on any of the problems and that many of the problems had my head spinning with recursion. Also, how many things from Jens’s talk “clicked” at different times during these exercises - I probably should re-watch that as there are probably many other things I hadn’t absorbed and I’ve not realised yet.

I’ve saved my progress on a repository, and included a file with things I was learning as I was going. During this set of exercises I’ve learnt to use the info command in emacs (C-h i), and how to search in the elisp manual. Interestingly, I’ve only read so far the firs four sections, up to lists, and it feels as I have super powers now. I can’t even imagine what I’ll be able to do when I read the other 37 other sections!

I’ve also starting to understand how to read the error messages and it has also helped me to debug problems that have appeared on emacs modules during this time.

In summary, Jens’s lecture helped a lot to get me started, exercism has been a great companion to get me “motivated” and to learn how others have solved the same problem (I still need to investigate the mentoring program they offer), and though the problems I’ve solved are labelled as easy, it feels so good to achieve these little things day after day. Now lisp doesn’t look that mysterious to me (well, it still does, but I can read it now!).

👋 Thanks for reading!

However, zoom is, by default, configured to switch to full-screen mode when someone is sharing the screen. It’s useful if you are watching some talk or lecture, but not that much if you need to code-along. As an instructor I didn’t realise this was a problem till a couple of weeks into one of the courses when a student gave us the following feedback:

the aspect ratio for Davids screen when he is screensharing means that anything he types is pretty much unreadable.

I believe this is related to that. Also, if the screen gets maximised and I’m sharing only half of the screen, they get half of the screen in the centre of their screen, leaving only one quarter on either side to work.

To get ready for my last workshop, and after multiple problems I’ve had wit zoom lately, I thought it would be better to test how my screen was seeing on different operative systems and using different clients (the desktop vs the browser client). Let’s see what I found.

In the sections below I’m testing by sharing some files and a terminal running on VS Code. The sharing was done by selecting only a portion of the screen option in the screen sharing menu in zoom.

What would you see when having a single screen?

Browser vs Zoom desktop app.

First I tried on Linux. On the left, we’ve got the web client on Firefox, on the right, the zoom app.

There are already some interesting differences.

1. The area! In the screenshot, the shared area shown by Firefox covers a 948x1133 px, whereas the desktop zoom app shows 879x1041. In Firefox you get 17% more than on the desktop.

   

   Why is that? Well, because the video from the presenter is shown as a floating window, that you can move around (even outside of the view) as you please, whereas in Zoom you are stuck to either have it on the top or on the side. Ideally, I could control where to appear, but I’ve had other problems with that.

2. The zoom actions menu. It hides on both applications, however, in Firefox doesn’t hide any content, whereas it does so in the desktop app.

   

   I find this very frustrating when you want to see something and the app keeps showing you a bar just because you hovered the mouse over. And by the time you calm down and stop moving the mouse, the thing you wanted to see is gone.

Focusing only on the shared screen, we should then prefer to use Firefox over the desktop app. You get more space and nothing hiding any of the important bits. However, if you need to also use the chat, then this may not be the best option. (We tend to not use the chat but a shared document instead). Additionally, you could even get more space hiding some bits from the firefox bar that you may not need.

How does this look in the Windows world?

In windows, the first browser I tried was Chrome, and to my surprised, it was different from Firefox on Linux. A popup appeared with the great news when you connect saying that you’ve got now a gallery/images view on Chrome! 🤦 That would have been awesome if it would let you choose which view you’d like. But it doesn’t!

With Firefox, however, you can still get the floating window for the webcams, but the area is not that different! The desktop app being ~5% larger. Though, the bottom menu bar will still hide part of the shared screen.

Multiple screens

If you’ve got more than one screen then you haven’t got many problems with space, right? However, there’s a nice feature of zoom that you can enable when using multiple screens, enabling dual monitors. This separates the zoom application into two windows, one for the bits being shared, and another where you can see the webcam of the participants.

This is the best of all the options! You get the zoom menu bar on the participants’ view, not hiding any of the content! Sadly, you need to have two screens… or do you? There’s some trickery we can do to our computers to make zoom believe that there are multiple screens and make this view available. However, this is not something I can ask my learners to set up before a class or a workshop. If you start zoom with a second screen connected, then I believe zoom keeps believing that you have that set up for the following calls. (Though it seems absurd that you find in such a situation, this trick has helped me many times where I can steal my girlfriend’s second monitor to start zoom and return it to her afterwards).

Final thoughts

First of all, I need to tell my students to disable the “enter full screen when a participant shares screen” option. This will at least let them place the window whenever they want.

Secondly, I need to test and re-test every time before teaching. In my last post, I explained why I had to use OBS. That worked fine for the teaching I needed to do in that time which didn’t require live-coding. However, when trying to use OBS to share only half of my screen I found a different problem. Since Zoom believes it’s your webcam that gets transmitted, Zoom keeps a webcam ratio on the screen, instead of what you normally get from a screen share, defeating the point of sharing half of the screen.

This time I went to “fix” zoom on my machine, and I did it by trying different versions you can install in Linux. The one that worked on my machine (Archlinux with Gnome over Wayland) was using flatpak. Or so I thought. I run all these tests, took lots of screenshots to share with my learners the optimal way to connect. During these tests I had noticed that my mouse pointer was not seen at all, but that was not new, I had to be more specific with my language. However, when I started teaching, I got one of the attendees saying “the screen is not changing”… 😱 Panic moment again! Zoom was not streaming my screen to the participants. Or well, it was, but only when I was hovering the mouse over the screen share bar that zoom creates. This meant I had to type and move the mouse every couple of seconds and made the flow of the workshop not as smooth as I would have liked it. Updating zoom again a couple of days later (from 5.6.1 to 5.7.xxx) seems to have fixed that issue on my latest tests.

If that was not enough, one of the attendees that tried to follow my indications to use Firefox on the university desktop couldn’t get the sound working, whereas the zoom app worked fine. Maybe I’ll design a flowchart before the next academic year starts so the students could get the most optimal setup with a less confusing set of instructions.

Zoom failing me (or me being super confident…)

I hadn’t taught that particular workshop for more than a year and I have prepared over the days before some diagrams to account for the whiteboard I had in the room last time I taught it. We were starting earlier than usual, so I left everything ready the night before, laptop, browser with the tabs open, terminal with the teaching setup, etc. At 9’00 am I started introducing myself and the workshop to the participants - all good so far (everyone could see and hear me). Then the teaching started.

Let me make a parenthesis and explain first my setup. I’ve found very useful the Zoom feature that allows sharing only a portion of the screen when teaching with a single screen. I’ve normally got the terminal, vs code, browser or whatever I need to show on my left half of the desktop. That allows me to keep my notes, the chat window, list of participants, etc on the right half.

When shared your screen like this, it’s suggested to tell your “viewers” to exit from the full-screen mode that Zoom starts automatically by default when someone shares their screen. If they don’t do so they’ll have my content in the middle of their screen and one-quarter of the screen free on each side to code-along. Not very useful, right? I’d recommend you disable that default behaviour.

Ok, back to my class. All was ready, I was full of energy and enthusiasm to try this fun workshop. But, when I shared my screen, I heard one saying “I don’t see anything”, and another “me neither”… Hum… That’s strange, Zoom is telling me I’m sharing. Ok, let’s try to get out of the call and back again. Same thing. Ok, then, let’s try to share the full screen (and keep my notes in my head). Nada. Then one of the participants said, “maybe you can try restarting the computer”. Ha! I did run an update recently, maybe that’s why. I restarted the computer, reconnect to the call… and I still can’t share. It was already 9’25 and we hadn’t started, so I decided to give it a go with my personal laptop. I connect, share the screen and yeah! people can see my screen!!! But all my files, diagrams, notes, etc. were on the other computer. Thankfully I got all my files in a single place that I could easily scp across, also most of the software I needed to be installed there too. In the end, we started almost 40 minutes late but we managed to cover the important bits we needed. Not as interactively as I had prepared, but people were happy at the end.

This last week I was having more teaching to do, and this time with less margin for problems as the workshop was two full days from 9 to 5. I knew we were going to use Zoom again, so I had to fix my problem before the teaching started. I browsed a bit to see whether people were having the same problem I had but I couldn’t find anything. I believe it may be related to the update to the newest version of gnome (40!) or the latest update of Zoom. I haven’t had the time to do much testing.

Entering OBS

I had used OBS (Open Broadcast Software) twice before, once for recording a tutorial for the translations of the Carpentries and another time for a talk about an autogradding tool (submitty). That last time had been more than a year ago and I had some problems. However, I had heard that the new version made some things easier! So, I decided to give it a go. Here I’m explaining the setup I used, how I “embedded” into my flow while teaching, what went well and what things didn’t work that well.

OBS is very neat! You can have multiple scenes, and switch between them with hotkeys from almost anywhere on your desktop. A scene is composed of one or many sources. A source could be your webcam, a static image, text, a window capture, etc. Each of these sources can be placed wherever you want in the scene. For example, you can get something like the image below, where I’ve got a scene (bottom left box) named Fun scene, with four sources (box next to “scene”): an image, some overlay text, a browser (shown below of OBS Studio) and my webcam.

If you want to stream that through Zoom/MS Teams/Blackboard/Jitsi or your favourite video conference tool, OBS provide now an easy way to tell these programs that you have a new webcam and that the content of that webcam is what you see on OBS. That’s done by clicking first on the “Start Virtual Camera” you can see on the set of buttons on the right-hand side, and then selecting that new webcam on your video conference tool. The image below shows where you can select that on Zoom.

If for any reason you don’t see the camera there, close the video conference program and open it again. At least that worked for me in Zoom.

I don’t know about other operative systems or Linux flavours, but for me, if OBS is using the webcam other programs can’t get the feed from the webcam at the same time. So, in Zoom, for example, I either have OBS camera or nothing, even if I got the option to choose the webcam.

This is a problem if I want to switch between them while I’m in a call as I can only show what I’ve got in OBS. Or… is it really a problem? You can have multiple scenes in OBS, remember? So, we could have one with only the webcam, and another with the scene where I’m presenting/sharing the stuff I want.

In this screenshot, I’ve got the studio mode enabled (button above the settings on the bottom left corner). With it, you get two views, a preview on the left and a program on the right. The view on the right would be what you are streaming, the one on the left is the one you can transition to. The buttons between these views let you choose which transition you want to use between one scene and another. There are a few options where to choose from, and a few more can be installed with additional plugins.

Great! The first problem solved! Now we don’t need to switch cameras in Zoom.

However, there’s another problem we will face. In Zoom (and similarly in other programs), when one shares the screen that gets “spotlighted” for everyone. This is, it becomes the main view for all, even when other people are talking. However, if we are telling these programs that we are using a “webcam”, then they are going to treat it as such and the main view will be switching from presenter to others if they talk. Fortunately, in Zoom, you can “spotlight” a particular presenter. This was one of the problems I had last year when I gave a talk using this because MS Teams didn’t allow me (and still doesn’t) to share my screen, we recorded the presentation for others that couldn’t attend it live… only to discover then that the recording had me and my slides in a corner.

At that time I didn’t think about that, but it seems MS Teams now has that option. I don’t know whether that works for the recordings too.

For the workshop I had this week I prepared three scenes:

• one with me (as the webcam)
• another sharing my browser (where I had my slides, the shared document, etc.)
• another with the browser and myself in a corner

The last one was to give a more personal view of the slides, so people could see my expressions and gestures when I was talking and not only the slides.

I set some hotkeys in OBS to transition between scenes. To do so, click on settings (bottom right corner), select the hotkeys section, and find the name of the scenes you want. Each of them has a “switch to scene” setting that you can input your keybindings for it. I used:

• ctrl+alt+m for the one with the presentation and myself
• ctrl+alt+n for the one with only the presentation and nothing else
• ctrl+alt+, for just me (the key next to m)

With that, I got a good mnemonic that was also with three keys next to each other in a meaningful order (n for presentation; m for both, ; for me).

From my side, this worked very well! I’ve got the transitions working well through the teaching and I was happy with myself. However, it was still not perfect! And thankfully, I’ve got a lot of feedback from the participants on this training session.

On the first day one of them wrote on the feedback:

Very minor bit of feedback but in the morning some of David’s face was often covered by the Zoom banner. Might be better to have it at the top of the slides instead of the bottom.

Of course, I hadn’t accounted for that! I had placed myself in the bottom right corer of the screen and many video conference tools have the obsession to place menus in top of the stream (and though they “disappear” after a while they come back again if your mouse passes by and you need to wait again a bit for it to disappear).

This was an easy fix! select the scene with me in the bottom corner and move the source to the top. Checked that the slides didn’t have anything important on that side and all sorted. (Read below how to make sure you are not hiding any text on your slides)

At the end of the workshop I received some more feedback:

When Evgenij (the other instructor) shared the screen I could use a side-by-side gallery of participants + shared screen focus (and annotation was available). When David used OBS these Zoom tools weren’t available, which worked less well for my setup.

This is the problem I mentioned above, Zoom is not seeing a screen share, but a webcam. Then we need to spotlight it if we want to keep it visible for everyone even if someone else talks. Though I don’t have a solution about annotating the presentation by the participants (and I saw a good use for it in this workshop!) I have, however, a solution about seeing the other participants at the same time. This is by enabling the dual monitors setting on Zoom. However, as the name says you need to have two monitors for Zoom to be able to work in this mode. I’ve found the following:

• There are some ways to create “virtual” screens on Linux [1], [2], [3], but haven’t tested them. I doubt they’ll work as I’m using Wayland.
• If you start Zoom and a call with two monitors and then disconnect one, Zoom doesn’t change behaviour. That’s good, that means I could trick Zoom to believe there is another screen.

• So, if when I connect only a cable/dongle to my laptop, then set

  echo on >  /sys/kernel/debug/dri/0/HDMI-A-1/force
  

  as root (thank ArchWiki), and on the display settings, select a new display and enable the toggle for it. When I start a call on Zoom, it starts with the two screens!

The next piece of feedback I got was:

OBS also blurred the quality for me

This is a bit trickier. I don’t know exactly where that’s happening, on OBS settings or Zoom. Let’s see the options I’ve found:

• OBS offers some pre-configured profiles depending you are using it for streaming, recording or virtual camera. On each of these, you can select the output resolution. I’ve played a bit with the video output settings and checked the outputs with Zoom on my side, and connected to a call from the browser. On my side, it seems OK, but when comparing with what’s obtained on the other side is really bad. This is how it looks!

  

  There are more settings on OBS, but I believe there may be something on the Zoom side.

• Zoom has also some settings for the webcam that I believe might also affect the quality of what’s sent: checks for original ratio, HD, touch up my appearance, and, under the advanced settings, optimise video quality with de-noise. Changing any of these parameters doesn’t show any improvement compared with what I showed above. However, when trying to connect to the call from a different computer - either using the web or desktop app - I could see a large improvement! The desktop app is slightly better.

I believe the “touch up my appearance” was selected during the workshop and that might have been what produced some of the blurs on the participants’ side. Now I wonder how many students from this year might think I’m way younger! Whenever we meet again in person people will think I’ve aged super quick because Zoom is hiding all my wrinkles!

Anyway, I should keep testing these quality parameters. Maybe recording the calls and checking that output. Doing these tests I’ve noticed that the web client besides showing a reduced quality, it also shows a delay that varies from 2-3 seconds when selecting text on a website, to up to 10 seconds if showing a video.

Let’s now look at some neat things I used on my OBS setup that may be helpful for others:

Webcam in a circle

I don’t know exactly why, but I’ve found it more “appealing” to have my head in a circle than in a square. Maybe because it leaves more space for what I’m presenting removing all these useless corners. In any case, this is what you need to do (based on the [How to get a circular webcam in OBS Studio][obs-circle] by Gael LEVEL):

• We need to create a mask. A mask is a grayscale image that indicates the opacity of what we want to show. Therefore we want to create a black image the same size as our webcam and draw a white circle in it. I used gimp for that. If your webcam has a resolution of 1280x720 pixels then you can get my mask. Otherwise, follow the steps below:
  • Find the right size of your webcam. One way to do so is using the resolution tool at the webcamtest website
  • Create a new image with these dimensions and fill the image with black.
  • Create a circle with the same height as the background in the centre and fill it white.
  • Export that image as a png.
• Create a new scene (name it for example webcam).
  • In that scene add a new Video Capture Device source.
  • If the webcam source video is larger than your “screen”, then you can click the right button, see the “transform” menu, and select “fit to screen”.
  • rename the source with something meaningful, e.g., webcam src
• Let’s now create a new scene (name it: webcam full),
  • As a source for that scene, we will choose a scene, webcam.
  • Yes! it seems that now we have two scenes that are equal, but this will be useful later.
• Let’s now create a scene with us full screen but in a circle, let’s name it webcam circle
  • We add as a source the webcam scene as we did before.
• Now, on the webcam circle scene (not in the source!) we click with the right button and select filters. In the new window that appears we add a new “Image mask/Blend” effect filter. You can name it as you like.
  • In the filter options select:
    • Type: Alpha Mask (Colour Channel)
    • Path: the path to your mask file created above.
    • Colour: #ffffff (white)
    • Opacity: 100.
• Now you can include that scene webcam circle as a source to the scene where you are sharing your browser/slides/desktop program/etc…

changing scenes with a nice move transition

If you’ve followed up the names from the steps above for the source and the scenes, then you won’t have many troubles in this step. Good luck if you haven’t.

The move transition plugin produces very neat transitions between scenes when these scenes contain the same sources but they may have different sizes, orientations or are in different locations. Check the “Move Transition - Install/Set Up - OBS” video by Optomod to see how it works.

The installation steps depend on your operative system and Linux flavour. For ArchLinux there’s a package for it at the Arch User repository.

Once installed, you can open the “move” settings under the “scene transitions” column. The first block of settings asks how you want the plugin to find out when two sources are “compatible”. I’ve got the three options selected (but the middle one - “numbers removed from end” is not required with the steps from above. You’ve got a bunch of other options to configure in these settings, play with them.

Now, using the studio mode, you can preview the transitions by clicking on move in the transitions menu shown between the two previews.

define transitions between scenes

A very useful plugin I used was the obs transition matrix. This “Transition Matrix OBS Guide” explains well in detail how to use it. In short, it allows you to define which transition you want to use when moving from one scene to another. So, you can go from the full webcam to the presentation and webcam with the move transition, but from the presentation and webcam to the presentation only with a fade.

set up slides

Finally, the last “trick” of today is not to do with OBS, but with google slides. If you are preparing a set of slides and you want to see whether your head is going to cover some bits, then you can create a colourful square/circle on the master slide positioned where your “head” is going to appear. This will make it easier for you to clearly distinguish that space across all the slides. When you have finished, you can go back to edit the master slides and remove the square you set.

And that’s all! Congratulations if you’ve got this far! Feel free to ask me anything about this or let me know you’ve found something wrong. Please, let me know if this has been helpful to you ;)

However… much has changed since 2014! Now there’s a repository for each lesson, the lessons are written in markdown and the community has grown a lot!

Since last summer there’s been a strong push by many on latinoamerica, and they’ve got a lot done! They have organised amazingly well, creating a glossary and style, a mailing list and get a bunch of dedicated volunteers! (67 members on the mailing list, and roughly counting more than 20 that have contributed to the translations on github!).

When talking about translations there are two main models one can follow, let’s call them upstream and wikipedia. There are probably more models, but I thing these are the two that needs an attention in this project. With upstream I am referring to a project that originates in a language, and the translations follow that. Think it as a book - El Quijote was written in Spanish and many translations appeared from it. There’s no way a translation will feed the author of the book to improve something. Another example is the menus and guides on software tools. If you use Firefox in Italian the words are translated from the English - there’s no a new functionality coming from the translation that needs to be brought into the upstream version. On the other hand, wikipedia has a translation of pages that are diverging. Some article may have been created in Tamil and someone translated into Turkish and then other contributors have added more information on the Turkish than what it was on the original Tamil article. However, another wikipedia editor may add these bits back into the original.

In the first case it’s very simple to track what’s been translated and what’s not, also, if something changes upstream, it’s easy to track too. On the wikipedia case it’s impossible (or almost impossible) to track - the articles become rapidly different enough to be considered a translation of the original. (And in a way that’s the beauty of wikipedia, right?)

What’s best for the Carpentries? Probably an hybrid between both. Anyone can contribute to the English lessons via a pull request, as for any software project. In the same manner the community can provide comments and suggestions via GitHub and the maintainers have the last power to decide what to merge and what not. If we have lesson A and lesson A-es, then similar process occur, and that’s great to fix translations, typos and similar “minor” changes. But what happens if the “es” community finds out about a better flow to teach a lesson? If such new approach can be generalised to other cultures then probably it could be brought up for discussion upstream and then after approval implement it in all the translated lessons (A-es, A-it, A-gr, …). However, if such change doesn’t make sense to other cultures then we have a diverging point. If it’s a simple change on the order on how something is taught (A.2 before A.1) probably we have the means to keep track of that, though if it’s something more intrinsic… then I don’t know what could be done.

What’s done now?

At the moment the lessons at the carpentries are “forks” (imported) of the style lesson. This workflow is well explained at the documentation (look at the diagrams!). In a similar manner, the translated lessons are imported from the original. The maintainer of the translated lesson will pull from upstream (the English one) and that will show the changes that need to be translated (probably as merge conflicts - though I’ve not suffered that myself yet).

On the other side, the translators take the original files and start translating them on the text editor. Sentence by sentence. When completed they make a pull request to the A-es repository, reviewed and finally merged.

What am I proposing?

Translations are hard! Mostly because you need to keep a flow and consistency over a text. You need to keep your glossary at hand and keep a track of what changes upstream without the need to re-read the whole text again to know where the new change belongs.

Thing is that we are not alone! Translations have been a common practice in many areas before. From legal documents on countries with more than an official language and companies that expand internationally to software used by many. We have to learn from them that have been doing it for decades. Many open source communities have created glossaries and style guides for their documentation (e.g., Gnome’s) and there are lots of tools to make the translation process easier and better to track.

The main tools used to translate (interfaces and documentation) by many software groups are based on gettext and PO files. These tools tokenise code or text and keep track of what happens to them. If in a new version only one token changes the special text editors (e.g., PoEdit, GTranslator, Lokalize) will show what needs to be updated. There’s other projects like Translate toolkit that offers lots of tools to work with these type of files.

Using these tools we could keep a track of what’s been translated, what’s new, find where we need help and visualise all that in a simple dashboard.

During the hack-day at the last Collaborations Workshop I tackle more of less of what’s need be done in terms of infrastructure. However, to make it work properly we would need some structure (again, imitating of what I learn from translators from Gnome).

1. Lessons release calendar. That helps translators to schedule time to focus on the translations of the lesson.
2. Have an editor (or few) for each language - similar role than the maintainer.
3. Main maintainer (English) don’t need to know about the languages as they may have been approved by the editors.
4. Glossary and writing style guides.

In the model I built (see figure below) I depend on two things. The first is that each lesson would use submodules to bring in the translations. That will make the url of the lessons something like: lesson/<lang>/index.html where <lang> is the language code. The second is to use Travis-ci to generate a dashboard with the translations progress for each lesson and each language and to generate the markdown files based on the po translated files and push them to the respective repository.

Each box represents a repository and the arrows are the connections as submodules between them. Travis would be in charge of making a dashboard and create and update the repositories with new translations.

What have I got so far?

In this test GitHub organisation I’ve got the markdown to po tool that I have adopted and modified so it works with the carpentries material. A central i18n repository where all the magic happens - keeps track via submodules of the upstream repositories and generates a gh-pages with a dashboard of what’s been done (still very crude).

What’s still needed?

To make the whole thing to work I still need certain things to work. These includes write tests, get Travis to generate the stats and new repositories and even a bot that analyses your PRs before they are merged (like pep8speaks or codecov reports)

What problems could this bring?

Translators will need to become familiar to use the po format. The good news is that there are plenty of tools that shows that in a nice way. However it is a tool to learn - whereas now they can just use a text editor. I think the advantages that these tools bring worth the learning.

Also this needs a change on how all the lessons are maintained. Will this be very disruptive to how are things now? I don’t think so, but this is why I’m trying this in a different set of repositories so I could show how everything works (if it does!).

More thoughts

While learning how everything “hangs” from the styles repository I’m thinking into convert that as a jekyll theme now that github allows to use them from github repositories. That would remove the task on the maintainers to keep up to date with the styles.