(Also published on Canonical's design team blog)

The weekend before last, I went to PyCon UK 2015.

I already wrote about the keynotes, which were more abstract. Here I'm going to talk about the other talks I saw, which were generally more technical or at least had more to do with Python.

Summary

The talks I saw covered a whole range of topics - from testing through documentation and ways to achieve simplicity to leadership. Here are some key take-aways:

The talks

Following are slightly more in-depth summaries of the talks I thought were interesting.

Friday

15:30: Leadership of Technical Teams - Owen Campbell

There were two key points I took away from this talk. The first was Owen's suggestion that leaders should take every opportunity to practice leading. Find opportunities in your personal life to lead teams of all sorts.

The second point was more complex. He suggested that all leaders exist on two spectra:

The less you know about a field the more hands-off you should be. And conversely, if you're the only one who knows what you're talking about, you should probably be more of a dictator.

Although he cautioned that people tend to mis-estimate their ability, and particularly when it comes to process (e.g. agile), people think they know more than they do. No-one is really an expert on process.

He suggested that leading technical teams is particularly challenging because you slide up and down the knowledge scale on a minute-to-minute basis sometimes, so you have to learn to be authoritative one moment and then permissive the next, as appropriate.

17:00: Document all the things - Kristian Glass

Kristian spoke about the importance, and difficulty, of good documentation. Here are some particular points he made:

One of Kristian's main points was that it goes against the grain to write documentation, 'cos the person with the knowledge can't see why it's important, and the novice can't write the documentation.

He suggested pair documentation as a solution, which sounds like a good idea, but I was also wondering if a StackOverflow model might work, where users submit questions, and the team treat them like bugs - need to stay on top of answering them. This answer base would then become the documentation.

Saturday

11:00: Asking About Gender - the Whats, Whys and Hows - Claire Gowler

Claire spoke about how so many online forms expect people to be either simply "male" or "female", when the truth can be much more complicated.

My main takeaway from this was the basic point that forms very often ask for much more information than they need, and make too many assumptions about their users. When it comes to asking someone's name, try radically reducing the complexity by just having one text field called "name". Or better yet, don't even ask their name if you don't need it.

I think this feeds into the whole field of simplicity very nicely. A very many apps try to do much more than they need to, and ask for much more information than they need. Thinking about how little you know about your user can help you realise what you actually don't need to know about your user.

11:30: Finding more bugs with less work - David R. MacIver

David MacIver is the author of the Hypothesis testing library.

Hypothesis is a Python library for creating unit tests which are simpler to write and more powerful when run, finding edge cases in your code you wouldn’t have thought to look for. It is stable, powerful and easy to add to any existing test suite.

When we write tests normally, we choose the input cases, and we normally do this and we often end up being really kind to our tests. E.g.:

def test_average():
  assert my_average([2, 4]) == 3

What Hypothesis does it help us test with a much wider and more challenging range of values. E.g.:

from hypothesis.strategies import lists, floats

@given(lists(floats()))
def test_average(float_list):
  ave = reduce(lambda x, y: x + y, float_list) / len(float_list)
  assert average(float_list) == ave

There are many cases where Hypothesis won't be much use, but it's certainly good to have in your toolkit.

Sunday

10:00: Simplicity Is A Feature - Cory Benfield

Cory presented simplicity as the opposite of complexity - that is, the fewer options something gives you, the more simple and straightforward it is.

"Simplicity is about defaults"

To present as simple an interface as possible, the important thing is to have many sensible defaults as possible, so the user has to make hardly any choices.

Cory was heavily involved in the Python Requests library, and presented it as an example of how to achieve apparent simplicity in a complex tool.

"Simple things should be simple, complex things should be possible"

He suggested thinking of an "onion model", where your application has layers, so everything is customisable at one of the layers, but the outermost layer is as simple as possible. He suggested that 3 layers is a good number:

He also mentioned that he likes README driven development, which seems like is an interesting approach.

11:00: How (not) to argue - a recipe for more productive tech conversations - Harry Percival

I think this one could be particularly useful for me.

Harry spoke about how many people (including him) have a very strong need to be right. Especially men. Especially those who went to boarding school. And software development tends to be full of these people.

Collaboration is particularly important in open source, and strongly disagreeing with people rarely leads to consensus, in fact it's more likely to achieve the opposite. So it's important that we learn how to get along.

He suggests various strategies to try out, for getting along with people better:

All of this comes down to stepping back, waiting and exercising humility. All of which are easier said than done, but all of which are very valuable if I could only manage it.

11:30: FIDO - The dog ate my password - Alex Willmer

After covering fairly common ground of how and why passwords suck, Alex introduced the FIDO alliance.

The FIDO alliance's goal is to standardise authentication methods and hopefully replace passwords. They have created two standards for device-based authentication to try to replace passwords:

Browsers are just starting to support U2F, whereas support for UAF is farther off. Keep an eye out.

14:30: Data Visualisation with Python and Javascript - crafting a data-visualisation for the web - Kyran Dale

Kyran demoed using Scrapy and Pandas to retrieve the Nobel laureatte data from Wikipedia, using Flask to serve it as a RESTful API, and then using D3 to create an interactive browser-based visualisation.