ScalaBridge London Season One

July 22, 2019

ScalaBridge aims to increase diversity within the Scala community by providing training in Scala to traditionally under-represented groups. ScalaBridge London is, as the name suggests, the London chapter of ScalaBridge. A month or so ago we finished the first “season” of ScalaBridge London. Now is a good time to reflect on what we did and how it worked out.

Background

ScalaBridge London started when I met Anna Bladzich at Scala Exchange in 2018. We shared a common interest in increasing diversity within the Scala community, and started talking about organising some events. I’d previously attended a few ScalaBridge events, which had all been one-off one day workshops, and I thought we needed something longer term if we really wanted to make a significant difference. We decided to try something a bit more permanent in London.

What We Did

We ran six evenings spread over twelve weeks. This makes our first season (though you could call it a semester or term if you prefer). We ended up spending about 18 hours in total with the students, of which about 12 was spent programming and remainder on socialising. We wanted to develop a good relationship with the students so when it came to providing the other kinds of support they might want, such as introducing them to prospective employers, they’d be comfortable approaching us. We also know people learn better when they learn with other people, and wanted the students to help support each other.

Once we had the overall plan there are four things to arrange:

  • venues to host our events;
  • students to attend and learn;
  • mentors to teach the students; and
  • curriculum material for the mentors to teach.

Our venues were provided by Scala employers around London. Most venues were also able to provide food. Huge thanks to the Guardian, iTV, Permutive, Elsevier, Depop, and Equal Experts for hosting us!

Our mentors came from the Scala community in London. Finding them was fairly easy as we could leverage our existing network. We discovered we tended to acquire new mentors with each new venue we visited, as the developers there saw how much fun it was!

Finding students was more challenging as we couldn’t tap into our existing network. It’s also the most important step! We advertised at:

  • London universities;
  • diversity focused meetups;
  • data science meetups;
  • Scala meetups;
  • on Twitter;
  • on LinkedIn; and
  • probably more places I don’t remember right now.

We divided students into three broad groups: those with very little or no programming experience, those who had experience but not with Scala, and those with Scala or other FP experience. Within each broad group we split the students into smaller groups of about 3, who worked with a single mentor.

As our curriculum we used Creative Scala for the beginners, and Essential Scala for the non-FP developers. For the Essential Scala group, which was the largest, we also wrote some lesson plans. The advanced developers we left to choose their own path in collaboration with their mentor.

We asked students to choose a project to work on outside of the meetings. The idea here was two-fold: we’d show how what we taught could be applied in a more realistic situation and we’d get the students extra practice.

What We Achieved

So, what did we achieve after twelve weeks? This is difficult to measure. The students don’t necessarily share the same goal and they definitely don’t all have the same background. Some will already be experienced programmers, whilst some will never have programmed before. Some will want to move into a Scala development role whilst some will just be there for fun. It isn’t our place to tell the students what they should get out of ScalaBridge. This means we can’t, for example, assess students on a final exam like a University course (and we wouldn’t want to, anywya). Instead we wanted to offer the opportunity and let the students make out of it what they desired.

One thing we can easily measure is attendence. We started with about sixty students, and ended with about twenty regular attendees. This proportion of dropouts is inline with what we expected. We were able to gather some information on why people dropped out, and the most common reasons were not having time or deciding that Scala was not for them. Variations in attendence did cause difficulties with creating consistent groups. Our advanced group in particular suffered from this.

Projects didn’t really happen. The students didn’t really have enough Scala experience to make significant progress on them outside of the sessions.

I have a good idea of student progress for the group I had the most involvement with (the beginners). They did very well. They had got to grips with structural recursion and most of them were working with first class functions by the time we finished. Given that we had about as much time with the students as two or three weeks of a University course I’m very happy with this. Of course the majority of the credit has to go to the students; they worked really hard!

I know less about how the other students progressed, but from what I saw they made good progress. The non-FP developers covered algebraic data types, structural recursion, first-class functions, and so on. I don’t think they got onto implicits but they covered most of the basic features of Scala.

Finally, we were able to help a student with job applications, which felt really good and is exactly the sort of thing that makes ScalaBridge London more a community and not just a course.

Next Steps

So that’s my recap for the first season. In the next ScalaBridge post I’ll talk about lessons learned and what we’ll change for next time.