The Scala Exchange program is (mostly) up, meaning we can comment on the effectiveness of our diversity programme aimed at getting new speakers into the conference. (Note the program is also open to new attendees, so if you’d like assistance attending Scala Exchange just follow the link above and fill in the application form.)
All up we had 17 applications from people who wanted shepherding for a talk proposal. Of these 14 submitted a talk proposal, giving new speakers approximately 20% of all proposals. Of these 14 proposals, 9 have currently been selected to present (with a few more in a waitling list). This is a 64% success rate for new speakers in being selected, compared to 70% for other speakers, with new speakers making up 18.75% of all speaking slots.
There isn’t enough data to make strong statements about differences in acceptance rates between new and experienced speakers. The data does suggest the rates are in the same region, and we’re very happy with this result. Read on to find out how we did it.
How We Did It
Going into the shepherding process we weren’t sure how we’d run it, but after we’d talked to a few applicants a pattern quickly became apparent. People often had an idea for a talk (sometimes we brainstormed a few ideas) but to refine it into a talk proposal we asked them to answer:
- who is the audience for your talk; and
- what are the main points you want your audience to take away from your talk?
These go hand-in-hand. If your audience is beginners they aren’t going to follow much type astronautics. If you want to talk about organisational issues you probably want to target team leaders and higher in the organisational chart. You can’t make more than three to five major points in a talk, and focusing on these issues really helped refine vague ideas into concrete proposals.
Once these questions had been answered we asked people to develop a talk outline. This mostly served to make sure there was a logical pathway through their main points, and sufficient material to make a talk. We generally didn’t spend very long on this step.
Finally we were ready to submit talk proposals. When writing the proposal we gave the following advice:
- Use the inverted pyramid style. That is, put the most important points first!
- A three paragraph structure is sufficient for most abstracts:
- First paragraph should say what the talk is about
- Second paragraph gives more motivation
- Third paragraph gives more details on talk content
It is important to realise there are two audiences for the proposal: the program committee and conference attendees (talk proposals are normally put as-is into the program). The program committee wants to know “is there an audience for this talk?” and “does the presenter have something coherent to say on the topic?” Attendees what to know “what’s in this talk for me?” Both want answers quickly. The answers to these questions have been developed in the first step of the process. The job of the abstract is simply to present them in any easy to digest format.
My talk proposal mostly stuck to this format, and is a reasonable example of the form.
In this talk I will discuss six fundamental concepts that underly effective Scala. How can programmers quickly and effectively learn to write idiomatic Scala? This is a question we at Underscore had to answer when developing our own training material. We knew we wanted to go beyond teaching syntax and give developers the concepts and techniques they needed to develop Scala in a systematic and idiomatic way. We identified six core concepts that cover a wide range of Scala programs. These concepts give programmers a reproducible way to create code -- once the problem domain is understood the code follows through a series of systematic and reproducible steps. The resulting code is robust and easily maintained. In this talk I will describe these six concepts, which are: - expressions, values, and types; - objects and methods; - algebraic data types; - structural recursion; - functors and monads; and - type classes. I will show how they let us create code in a systematic manner, and how we can go about teaching the concepts to new Scala developers. This talk should be of interest to anyone who is transitioning to, or leading a team that is transitioning to, Scala, and anyone interested in guidelines for idiomatic Scala code.