Musings by @thedevel

PyCon 2013 - Attended Talks

1097 words · 19 Mar 2013

This is a quick listing and assessment of the talks I attended at PyCon 2013. I use an arbitary scale: "Bad", "Poor", "OK", "Good", "Great"

Messaging at Scale at Instagram

Slides: https://speakerdeck.com/pyconslides/messaging-at-scale-at-instagram-by-rick-branson

  • Content: Good
  • Presentation: Good
  • Delivery: Good

I've used RQ for a recent project due to it's simplicity and actually resisted using Celery and RabbitMQ. However, this talk has convinced me to check out the latter again due to it's robustness and improved APIs.

The End of Object Inheritance & The Beginning of a New Modularity

Slides: (not yet posted)

  • Content: Good
  • Presentation: Good
  • Delivery: Great

This drove home making an effort in writing composable code especially for API design. It is very easy to get obsessed with inheritance just for the sake of abstraction (ahem.. Java). A subclass that is assumed to use one or more other methods on the class can cause a leaky abstraction when not used correctly.

The more sound approach is to use OOP when defining object protocol/interface and using subclasses to override or implement various behaviors. Objects that depend on those protocols should not subclass the same class, but rather utilize an instance of the class for interacting with it.

This is not a monumental realization for me by any means, but it was a well delivered and purposeful talk.

The Magic of Metaprogramming

Slides: https://speakerdeck.com/pyconslides/the-magic-of-metaprogramming-by-jeff-rush

  • Content: Good
  • Presentation: Poor
  • Delivery: OK

The most interesting part about this talk was seeing just how flexible Python is. A few things from the talk:

  • conditional based imports
    • import hooks which enable importing different modules by the same name depending on the context
  • metaclasses
    • I use these sparingly, but they are very useful in some cases
  • class decorators
    • easy to use, but are more limiting than metaclasses (they are not inherited by subclasses)
  • method decorators
    • commonly used and are very useful

The most interesting use case of applying the import hooks and/or using metaclasses is that that logic is self-contained and can be applied without dirtying the rest of the code. For example, an audit of of method calls could be performed by adding a metaclass the base class of the inheritance chain. Further more, this could done dynamically via an conditionally imported module if some audit flag is marked as true.

Cool stuff.

Python 3.3: Trust Me, It's Better than 2.7

Slides: https://speakerdeck.com/pyconslides/python-3-dot-3-trust-me-its-better-than-python-2-dot-7-by-dr-brett-cannon

  • Content: Great
  • Presentation: OK
  • Delivery: OK

This was basically an attempt to sell the audience on everyone should start using 3.3. The features sold themselves. Run through the slide deck to see what's new or what has changed.

Fighting Cancer with Python

Slides: (not yet posted)

  • Content: Poor
  • Presentation: OK
  • Delivery: OK

This is a commerical entity using Python for doing research on cancer. I appreciate and support the utility here, however the presentation was not great. A few of common scientific tools were listed, but the actual techniques, workflow or architecture were not discussed.

Python Profiling

Slides: https://speakerdeck.com/pyconslides/python-profiling-by-amjith-ramanujam

  • Content: OK
  • Presentation: OK
  • Delivery: Good

Quick overview of the state of (CPU) profiling tools in Python. Unfortunately he did not discuss any profiling techniques for making the developer themself better at knowing what or how to optimize their code. Also, by the end the presenter was talking about how his employer's product is solving this problem and why everyone should use it.

Awesome Big Data Algorithms

Slides: https://speakerdeck.com/pyconslides/awesome-big-data-algorithms-by-titus-brown

  • Content: Good
  • Presentation: OK
  • Delivery: Poor

Overview and examples of three random and probabilistic algorithms for dealing with big data. View the slide deck for details.

Functional Programming with Python

Slides: https://speakerdeck.com/pyconslides/functional-programming-with-python-by-dr-dot-ing-mike-muller

  • Content: OK
  • Presentation: Poor
  • Delivery: Poor

Eh. I guess this is what I get for listening to a Python teacher explaining functional techniques.

Things to Make Writing Tests Easer

Slides: https://speakerdeck.com/pyconslides/things-to-make-writing-tests-easier-by-chris-withers

  • Content: OK
  • Presentation: OK
  • Delivery: OK

I don't remember much from this talk since I walked out half way into it. He was discussing some of the tools he has developed for improving how equalities between objects and such work.

How (Not) to Build an OSS Community

Slides: https://speakerdeck.com/pyconslides/how-not-to-build-an-oss-community-by-daniel-lindsley

  • Content: Great
  • Presentation: Great
  • Delivery: Great

This was a great talk. Run through the slides to see the main points. I made a GitHub Wiki template repo that defines a few pages that match what the talk focuses on here: https://github.com/bruth/oss-community-wiki with details on the wiki itself.

Logical Failures

Slides: https://speakerdeck.com/pyconslides/logical-failures-by-luke-sneeringer

  • Content: OK
  • Presentation: Poor
  • Delivery: OK

This was more of a fast-paced "Logic 101" talk. It was a tad too fast at times and was very light with any reference to Python or programming in general.

Let them Configure!

Slides: https://speakerdeck.com/pyconslides/let-them-configure-by-lukasz-langa

  • Content: Good
  • Presentation: OK
  • Delivery: Poor

The intention of the talk was good and the content was generally good, but was not presented very well (there was a bit of language barrier). The basic premise is that you as an application developer should always use an existing well-adopted format unless you absolutely need to create your own. If so, use a dialect or a superset of an existing format and document the hell out of the differences.

The other side of the talk about discussing the pros and cons of the various existing formats like .ini, .json, etc.

Going Beyond the Django ORM Limitations with Postgres

Slides: https://speakerdeck.com/pyconslides/going-beyond-the-django-orm-limitations-with-postgres-by-craig-kerstiens

  • Content: Good
  • Presentation: Good
  • Delivery: Good

This talk focused on a few Django apps that extend the ORM to use Postgres-specific functionality like the list type, hstore, and full-text search. I was aware of most of these apps, but the main takeaway for me (and a point the speaker was making) was problem with using an ORM that enforces a consistent level of abstraction across all database backends. It sucks the fact that SQLite and MySQL are more limiting in certain respects than Postgres and therefore some of the best features of Postgres are not exposed in the ORM.

Namespaces in Python

Slides: https://speakerdeck.com/pyconslides/namespaces-in-python-by-eric-snow

  • Content: Poor
  • Presentation: Bad
  • Delivery: Bad

Not what I expected, I thought he was going to talk about Implicit Namespace Packages. What a way to end the conference.

Other Notables