“Connascence” is a way of describing the ways in which parts of software are interdependent, and can thus force changes upon other parts when they themselves are changed. In other words: Connascence lets us understand the degree to which changes in A will force changes in B. In this talk, Thomi Richards introduces the idea of connascence, describing and demonstrating different types of coupling and connascence in Python code. Understanding the types and degrees of connascence present in your software will make it easier to understand the impact of change, and will help you to reason more carefully about the software you write.
Most programmers like to make their code more efficient. Whether it’s improving our algorithms, adopting new languages, or just cleaning out old code, we want to make our programs run faster and use fewer resources. But in this talk, Cory Benfield tells us that the problem with much of our code has to do with the fact that we’re using blocking I/O, and that we could improve things dramatically if we were to use asynchronous code. Asynchronous I/O is an area of growing interest and development in several programming languages, including Python (especially the recently-released 3.5) and JavaScript in (ES6).
Python 3.5 was released earlier this week, and while many Python developers still use 2.7, there is growing interest in the advanced features that Python 3.x provides. That said, many developers wonder why it’s worth upgrading to Python 3. In this talk, Steve Dower describes some of the most interesting and useful new features that Python 3.5 brings to the table. Note that his talk doesn’t cover all of the latest goodies in 3.5, or even items that were already in 3.4. However, if you’re considering whether you should use Python 3.5, this talk should make it clear that if you can, using Python 3.5 is no longer a “nice to have,” but will make your code more maintainable and flexible.
Data science is all about working large data sets. Data scientists often perform experiments, in order to find interesting and useful correlations. But it’s easy to perform analyses that aren’t accurate, or that help you to draw conclusions that are less than accurate. How can you be sure that your analysis is robust? Use techniques that embrace your doubts, and allow you to demonstrate to yourself and others that the correlations you’re seeing really exist. In this talk, Hillary Green-Lerman introduces this problem, and then describes solutions which allow you to confidently describe the conclusions you’re drawing from your data-science experiment.
Coroutines are an advanced Python feature that is of growing interest to many Python developers. Coroutines can be hard to get your head around, but they make it possible to simplify certain types of software, and also to increase some software performance. But what are coroutines, how do you create them, how do you use them — and are they really that great? In this talk, A. Jesse Jiryu Davis demonstrates how you can and should use coroutines, and where they fit into the Python ecosystem.
Python is easy to learn, which accounts in no small part for its skyrocketing popularity. But an easy-to-learn language can also be powerful, with advanced data types and uses. Python has many such features, which advanced users know and love, but which new users probably don’t know about. In this talk, Andrey Syschikov introduces several of the more advanced aspects of Python, including iterators, generators, and context managers. He shows that they’re not only interesting, but also useful in our day-to-day coding.
Programmers love to advocate for their favorite languages. “I love language X, so why doesn’t everyone else use language X?” As a growing number of businesses use multiple languages, you can end up with pockets of different advocates, many of whom are then adamant that their language be used for more things. In this talk, Adam Forsyth describes life as a Python developer in a mostly-Ruby shop — and then goes on to describe when, much as he likes Python, it isn’t an appropriate tool to use.
Yesterday’s talk was about the creation of the JVM, and what design considerations went into that process. The JVM is no longer just for Java, and that raises a number of issues that the original JVM implementation never had to think about. In particular, there are a number of JVM-based languages for which the JVM version isn’t the sole or even main version — such as Jython (Python) and JRuby (Ruby). In this talk, Mark Stoodley describes the work that IBM has done to improve JVM performance for alternative languages.
When you speak with someone else, are you ever sarcastic? Of course you are. How do you know if someone is being sarcastic when they speak? And is there a way that we can detect that sarcasm automatically? It turns out that the answer is “yes” — we can detect sarcasm automatically, to a larger degree than you might believe. Amazingly enough, this can be done using a lot of common, open-source tools written in Python. In this talk, Rachel Rakov describes her research into the detection of sarcasm, and describes the ways in which she is using Python tools to conduct it.
Yesterday’s video described the GIL in Python — its history, current usage, and future. It would seem that Python is destined to have a GIL in the foreseeable future. However, the PyPy alternative implementation of Python was designed to be a sandbox for new ideas, and for trying new ways of doing things in Python. One such idea is to bring software transactional memory (STM) to Python, simultaneously providing for concurrency and safety. How does STM work in PyPy? What does it change in the language? And why is this not already a part of Python? In this talk, Armin Rigo describes his work to integrate STM into PyPy, and what this means for Python developers now and in the future.