Notes: Boston Python User Group, Lightning Talks, 22 June 2015

On 22 June 2015, the Boston Python User Group had a night of seven lightning talks. These are notes I took for personal use; they're not a perfect re-telling of what each talk was about (or even what each talk was called).

#1 Python for making connections in groups

Speaker: John Hess

John and a friend distant from him in his social graph each ended up being stood up by friends at the same bar. They decided to sit down and solve the world's problems. They ended up enjoying their time, so John wanted to find a way to automate this sort of process.

The idea is something like this:

• A group of people sign up on Maven
• The service selects a group of about 4-6 people and texts them to see if they're available
• As people accept or decline invitations to the event, Maven will text more people from the group to get them in on the event
• Maven then puts everyone into a group message so they can organize the event

John found that:

• Building stuff is easy in Python
• Python is a Swiss army knife, but it can't do everything (for example, mobile development)
• While building stuff is easy, building stuff that is user friendly is really hard
• John kept iterating, putting the product in front of friends, getting feedback, and trying new things

#2 Django cloud management

Speaker: Robert Paul Chase

I was semi-lost on this one. The project was related to genetics somehow, and I know nothing about computational genetics.

He built a cloud management platform that lets biologists and researchers (read: not developers) easily spin up nodes, install necessary software, run their code, and kill their cluster when they're done with it.

#3 .format()ing without tears

Speaker: Richard Landau

The standard str.format() method in Python will throw a KeyError if a name isn't found in the dictionary. Rick made his own function to avoid that problem. Here's how it works:

• Uses a regex to get the names both with and without braces (e.g. "{foo}" and "foo")
• Zips those two arrays together (to get ('foo', '{foo}'), ('bar', '{bar}'), ('baz', '{baz}'))
• Constructs a dictionary from that array (the format of the tuples will work with dict())

At first, it seemed to me like another way to implement this behavior would be to provide .format() with a dictionary that, instead of throwing a KeyError when encountering an unknown key, would return a modified version of the key which was asked for. I tried to do that, and it turns out that doesn't work

class FancyDict(object):
    def __init__(self, dictionary):
        self.__dictionary = dictionary

    def __getitem__(self, key):
        try:
            return self.__dictionary[key]
        except KeyError:
            return '{' + key + '}'

    def keys(self):
        return self.__dictionary.keys()

if __name__ == '__main__':
    params = { 'foo': 'this is foo', 'bar': 'this is bar', 'baz': 'this is baz' }
    print '{foo} {bar} {baz}'.format(**params)
    # this is foo this is bar this is baz

    params = { 'foo': 'this is foo', 'bar': 'this is bar' }
    print '{foo} {bar} {baz}'.format(**params)
    # KeyError: 'baz'

    params = FancyDict({ 'foo': 'this is foo', 'bar': 'this is bar' })
    print '{foo} {bar} {baz}'.format(**params)
    # KeyError: 'baz'

str.format() gets the keys of the dictionary and will throw a KeyError if any of the strings in curly braces are absent.

#4 Test all the data

Speaker: Eric J Ma

• Testing data is important because you have some assumptions about it that may not always be correct
• He talked some more about how to do that using PyTest

#5 Visualizing Yeast ChIP-Seq data

Speaker: Luis Soares

I was completely out of my league on the domain of this one, which was something related to biology.

It looked like a neat web-based visualization project.

#6 Payment reform

Speaker: James Santucci

I wasn't super familiar with the domain (statistics).

The big takeaway was that how we measure value affects how much value we observe. I'm not sure what that means.

#7 Hypothesis: property-based testing

Speaker: Matt Bachmann

• Hypothesis is a Python library inspired by Haskell's QuickCheck
• You put a decorator on your test to say what kind of data it takes
• It works with most testing frameworks
• You write a small amount of code, but get a big amount of functionality tested