PyTexas 2024 Recap

This was my first year at PyTexas. The best thing about the community surrounding Python is that the language is versatile to not only software engineers, but to other professions. I've played with alot of tooling and programming languages and I can say with confidence that Python has the least amount of gatekeeping when compared to other communities. I learned so much at this conference (also, yes - that is an inflatable Buccee).

Takeaways

Here are some of my opinions on the things I learned in a jam-packed 2 days worth of sessions.

Designing Good APIs and Writing Pythonic Code

Lynn Root's talk on designing APIs was exceptional. I found it quite interesting on how she bridged Don Norman's design principles over to building APIs that are not only easy to use but heighten the developer experience. As someone who prioritizes developer experience in my choice of tools, I found her talk particularly engaging. Her arguments were based on three main tenets - APIs should be intuitive, flexible, and simple. By emphasizing aspects like naming, language conventions, and ensuring predictability in the outcomes of API actions, she convincingly argued for a strategy that promotes wider adoption of service consumption.

Heather Crawford's talk on writing Pythonic code was another highlight for me. Having delivered several local talks on the same subject, I was intrigued to see how our perspectives aligned. My programming background is rooted in Java and TypeScript, and I noticed a tendency to carry over the same development style to Python. However, this isn't ideal given the stark contrast in idiomatic principles between these languages. She shared a similar experience while training Bloomberg employees transitioning from C++. It's crucial when learning Python, or any new language, to adopt the existing style and conventions. Python, in particular, advocates for code that is as readable as English, concise, and straightforward.

The Striking Balance Between Maintainers and Contributors

Another talk I really enjoyed was Bernát Gábor's on maintaining OS projects. He maintains many projects including Tox, virtualenv, and others. He emphasized significant differences between contributing to and maintaining open-source projects, a distinction that is often overlooked. While contributing often involves addressing isolated issues or adding new features, maintaining requires a holistic view of the project. It involves ensuring the project's long-term viability, managing community interactions, and making critical decisions about the project's direction. My main takeaway from his talk was that each pull request, discussion, and question answered needs to be resolved with the project's idea and vision in mind.

Check the Engine, Don't Just Drive the Car

Given the high-level abstraction and user-friendly nature of Python, it's common for us to overlook the internals. This was a theme addressed by both Andy Fundinger and Moshe Zadka in their respective talks.

Andy's talk focused on the use of sets in Python as a tool for enhancing performance. Sets, as a built-in data type in Python, are collections of unique elements. They are unordered, meaning that the items have no index. Their primary use is to perform operations like union, intersection, and difference, akin to what we do in mathematical sets. He explained how this data structure can lead to significant efficiency gains, especially in scenarios where you need to handle and perform operations like checking for membership or removing duplicates instead of using structures like lists.

Moshe emphasized the critical role of iterators and generators in Python. Iterators are objects that can be iterated (or looped) upon. An object which will return data, one element at a time. They are at the core of Python's most powerful features, including for loops, list comprehension, and generators. Both talks served as a reminder for all developers that refreshing upon these lower-level aspects of Python can lead to writing more efficient and effective code.

You Can Make Programming Fun

Last but not least, the main takeaway from this conference for me is that programming is fun IF you want it to be. As a guitarist, I really liked Peter Sobot's presentation on using the Pedalboard library to alter and transform audio with just a few lines of code. Al Sweigart's presentation on how cool you can make ASCII art with minimal dependencies and overhead make it a great tool for budding programmers. Since you can hear sound and see art, writing programs with the techniques and tools from these talks make it approachable for beginners to learn to write code that haven't done so before. The feedback loop that these types of projects provide give that ability to keep pushing forward that other types of projects don't. It reminded me of why I got into programming in the first place - I like tinkering and flexing my creativity muscle.