The Python Podcast.__init__

Tobias Macey

Boost

Boost

The podcast about Python and the people who make it great

Update Your Model's View Of The World In Real Time With Streaming Machine Learning Using River

Preamble This is a cross-over episode from our new show The Machine Learning Podcast, the show about going from idea to production with machine learning. Summary The majority of machine learning projects that you read about or work on are built around batch processes. The model is trained, and then validated, and then deployed, with each step being a discrete and isolated task. Unfortunately, the real world is rarely static, leading to concept drift and model failures. River is a framework for b

Dec 12, 2022 • 1:16:23

Declarative Machine Learning For High Performance Deep Learning Models With Predibase

Preamble This is a cross-over episode from our new show The Machine Learning Podcast, the show about going from idea to production with machine learning. Summary Deep learning is a revolutionary category of machine learning that accelerates our ability to build powerful inference models. Along with that power comes a great deal of complexity in determining what neural architectures are best suited to a given task, engineering features, scaling computation, etc. Predibase is building on the succe

Dec 5, 2022 • 59:22

Build Better Machine Learning Models With Confidence By Adding Validation With Deepchecks

Preamble This is a cross-over episode from our new show The Machine Learning Podcast, the show about going from idea to production with machine learning. Summary Machine learning has the potential to transform industries and revolutionize business capabilities, but only if the models are reliable and robust. Because of the fundamental probabilistic nature of machine learning techniques it can be challenging to test and validate the generated models. The team at Deepchecks understands the widespr

Nov 28, 2022 • 47:37

Build A Full Stack ML Powered App In An Afternoon With Baseten

Preamble This is a cross-over episode from our new show The Machine Learning Podcast, the show about going from idea to production with machine learning. Summary Building an ML model is getting easier than ever, but it is still a challenge to get that model in front of the people that you built it for. Baseten is a platform that helps you quickly generate a full stack application powered by your model. You can easily create a web interface and APIs powered by the model you created, or a pre-trai

Nov 21, 2022 • 45:22

Skip Straight To The Fun Part Of Your Project With PyScaffold

Summary Starting a new project is always exciting and full of possibility, until you have to set up all of the repetitive boilerplate. Fortunately there are useful project templates that eliminate that drudgery. PyScaffold goes above and beyond simple template repositories, and gives you a toolkit for different application types that are packed with best practices to make your life easier. In this episode Florian Wilhelm shares the story behind PyScaffold, how the templates are designed to reduc

Nov 7, 2022 • 57:46

Add Configuration Best Practices To Your Application In An Afternoon With Dynaconf

Summary Application configuration is a deceptively complex problem. Everyone who is building a project that gets used more than once will end up needing to add configuration to control aspects of behavior or manage connections to other systems and services. At first glance it seems simple, but can quickly become unwieldy. Bruno Rocha created Dynaconf in an effort to provide a simple interface with powerful capabilities for managing settings across environments with a set of strong opinions. In t

Oct 30, 2022 • 1:03:59

Take A Tour Of The Hidden Language Of Hardware And How It Powers Your Code

Summary Software is eating the world, but that code has to have hardware to execute the instructions. Most people, and many software engineers, don’t have a proper understanding of how that hardware functions. Charles Petzold wrote the book "Code: The Hidden Language of Computer Hardware and Software" to make this a less opaque subject. In this episode he discusses what motivated him to revise that work in the second edition and the additional details that he packed in to explore

Oct 23, 2022 • 41:50

Take Control Of Your Electrical Systems With The Open Source FlexMeasures Energy Management System

Summary The generation, distribution, and consumption of energy is one of the most critical pieces of infrastructure for the modern world. With the rise of renewable energy there is an accompanying need for systems that can respond in real-time to the availability and demand for electricity. FlexMeasures is an open source energy management system that is designed to integrate a variety of inputs intelligently allocate energy resources to reduce waste in your home or grid. In this episode Nicolas

Oct 16, 2022 • 49:17

How And Why To Build Effective Teams As An Engineering Leader

Summary Your ability to build and maintain a software project is tempered by the strength of the team that you are working with. If you are in a position of leadership, then you are responsible for the growth and maintenance of that team. In this episode Jigar Desai, currently the SVP of engineering at Sisu Data, shares his experience as an engineering leader over the past several years and the useful insights he has gained into how to build effective engineering teams. Announcements Hello and

Oct 10, 2022 • 1:04:50

Complete Your Hardware "Weekend Projects" In An Actual Weekend With Belay

Summary Working on hardware projects often has significant friction involved when compared to pure software. Brian Pugh enjoys tinkering with microcontrollers, but his "weekend projects" often took longer than a weekend to complete, so he created Belay. In this episode he explains how Belay simplifies the interactions involved in developing for MicroPython boards and how you can use it to speed up your own experimentation. Announcements Hello and welcome to Podcast.__init__, the podca

Oct 3, 2022 • 48:30

Catching Up With Pyre, A Fast Type Checker For Python

Summary Static typing versus dynamic typing is one of the oldest debates in software development. In recent years a number of dynamic languages have worked toward a middle ground by adding support for type hints. Python’s type annotations have given rise to an ecosystem of tools that use that type information to validate the correctness of programs and help identify potential bugs. At Instagram they created the Pyre project with a focus on speed to allow for scaling to huge Python projects

Sep 19, 2022 • 51:45

Standardizing On Python For All Software Projects At Ascend.io

Summary Every software project is subject to a series of decisions and tradeoffs. One of the first decisions to make is which programming language to use. For companies where their product is software, this is a decision that can have significant impact on their overall success. In this episode Sean Knapp discusses the languages that his team at Ascend use for building a service that powers complex and business critical data workflows. He also explains his motivation to standardize on Python for

Sep 13, 2022 • 50:26

Exploring The Process And Practice Of Building Better Software Through Code Reviews

Summary Writing code is only one piece of creating good software. Code reviews are an important step in the process of building applications that are maintainable and sustainable. In this episode On Freund shares his thoughts on the myriad purposes that code reviews serve, as well as exploring some of the patterns and anti-patterns that grow up around a seemingly simple process. Announcements Hello and welcome to Podcast.__init__, the podcast about Python’s role in data and science. When

Sep 5, 2022 • 57:24

Ship With Confidence By Automating Quality Assurance

Summary Quality assurance in the software industry has become a shared responsibility in most organizations. Given the rapid pace of development and delivery it can be challenging to ensure that your application is still working the way it’s supposed to with each release. In this episode Jonathon Wright discusses the role of quality assurance in modern software teams and how automation can help. Announcements Hello and welcome to Podcast.__init__, the podcast about Python’s role in

Aug 28, 2022 • 1:09:05

Remove Roadblocks And Let Your Developers Ship Faster With Self-Serve Infrastructure

Summary The goal of every software team is to get their code into production without breaking anything. This requires establishing a repeatable process that doesn’t introduce unnecessary roadblocks and friction. In this episode Ronak Rahman discusses the challenges that development teams encounter when trying to build and maintain velocity in their work, the role that access to infrastructure plays in that process, and how to build automation and guardrails for everyone to take part in the

Aug 14, 2022 • 1:01:49

The Benefits Of Python And Django For Going From Zero To MVP At Speed

Summary Every startup begins with an idea, but that won’t get you very far without testing the feasibility of that idea. A common practice is to build a Minimum Viable Product (MVP) that addresses the problem that you are trying to solve and working with early customers as they engage with that MVP. In this episode Tony Pavlovych shares his thoughts on Python’s strengths when building and launching that MVP and some of the potential pitfalls that businesses can run into on that path.

Jul 31, 2022 • 47:06

Powering The Next Generation Of Application Architectures With Web Assembly And The Fermyon Platform

Summary Application architectures have been in a constant state of evolution as new infrastructure capabilities are introduced. Virtualization, cloud, containers, mobile, and now web assembly have each introduced new options for how to build and deploy software. Recognizing the transformative potential of web assembly, Matt Butcher and his team at Fermyon are investing in tooling and services to improve the developer experience. In this episode he explains the opportunity that web assembly offer

Jul 25, 2022 • 1:10:40

Gain A Deeper Understanding Of What Your Code Is Doing And Where It Spends Its Time With VizTracer

Summary As your code scales beyond a trivial level of complexity and sophistication it becomes difficult or impossible to know everything that it is doing. The flow of logic and data through your software and which parts are taking the most time are impossible to understand without help from your tools. VizTracer is the tool that you will turn to when you need to know all of the execution paths that are being exercised and which of those paths are the most expensive. In this episode Tian Gao exp

Jul 17, 2022 • 48:33

Stream Processing In Real Time And At Scale In Pure Python With Bytewax

Summary Analysis of streaming data in real time has long been the domain of big data frameworks, predominantly written in Java. In order to take advantage of those capabilities from Python requires using client libraries that suffer from impedance mis-matches that make the work harder than necessary. Bytewax is a new open source platform for writing stream processing applications in pure Python that don’t have to be translated into foreign idioms. In this episode Bytewax founder Zander Mat

Jul 10, 2022 • 42:32

Tetra: A Full Stack Web Framework That Doesn't Make You Write Everything Twice

Summary Building a fully functional web application has been growing in complexity along with the growing popularity of javascript UI frameworks such as React, Vue, Angular, etc. Users have grown to expect interactive experiences with dynamic page updates, which leads to duplicated business logic and complex API contracts between the server-side application and the Javascript front-end. To reduce the friction involved in writing and maintaining a full application Sam Willis created Tetra, a fram

Jul 3, 2022 • 53:07

Design Real-World Objects In Python With CadQuery

Summary Virtually everything that you interact with on a daily basis and many other things that make modern life possible were designed and modeled in software called CAD or Computer-Aided Design. These programs are advanced suites with graphical editing environments tailored to domain experts in areas such as mechanical engineering, electrical engineering, architecture, etc. While the UI-driven workflow is more accessible, it isn’t scalable which opens the door to code-driven workflows. I

Jun 27, 2022 • 45:04

Intelligent Dependency Resolution For Optimal Compatibility And Security With Project Thoth

Summary Building any software project is going to require relying on dependencies that you and your team didn’t write or maintain, and many of those will have dependencies of their own. This has led to a wide variety of potential and actual issues ranging from developer ergonomics to application security. In order to provide a higher degree of confidence in the optimal combinations of direct and transitive dependencies a team at Red Hat started Project Thoth. In this episode Fridolín Pokor

Jun 15, 2022 • 31:32

Take A Deep Dive On How Code Completion Works And How To Customize It

Summary Most developers have encountered code completion systems and rely on them as part of their daily work. They allow you to stay in the flow of programming, but have you ever stopped to think about how they work? In this episode Meredydd Luff takes us behind the scenes to dig into the mechanics of code completion engines and how you can customize them to fit your particular use case. Announcements Hello and welcome to Podcast.__init__, the podcast about Python’s role in data and scie

May 30, 2022 • 1:00:11

Hunting Black Swans With Bees: Catching Up With The Inimitable Russell Keith-Magee

Summary Russell Keith-Magee is an accomplished engineer and a fixture of the Python community. His work on the Beeware suite of projects is one of the most ambitious undertakings in the ecosystem and unfailingly forward-looking. With his recent transition to working for Anaconda he is now able to dedicate his full focus to the effort. In this episode he reflects on the journey that he has taken so far, how Beeware is helping to address some of the threats to Python’s long term viability, a

May 24, 2022 • 56:11

Take Control Of Your Digital Photos By Running Your Own Smart Library Manager With LibrePhotos

Summary Digital cameras and the widespread availability of smartphones has allowed us all to generate massive libraries of personal photographs. Unfortunately, now we are all left to our own devices of how to manage them. While cloud services such as iPhotos and Google Photos are convenient, they aren’t always affordable and they put your pictures under the control of large companies with their own agendas. LibrePhotos is an open source and self-hosted alternative to these services that pu

May 16, 2022 • 45:15

Making Investment Data Easy To Access And Analyze With The OpenBB Terminal

Summary Investing effectively is largely a game of information access and analysis. This can involve a substantial amount of research and time spent on finding, validating, and acquiring different information sources. In order to reduce the barrier to entry and provide a powerful framework for amateur and professional investors alike Didier Rodrigues Lopes created the OpenBB Terminal. In this episode he explains how a pandemic project that started as an experiment has led to him founding a new c

May 10, 2022 • 47:14

Accelerate Your Machine Learning Experimentation With Automatic Checkpoints Using FLOR

Summary The experimentation phase of building a machine learning model requires a lot of trial and error. One of the limiting factors of how many experiments you can try is the length of time required to train the model which can be on the order of days or weeks. To reduce the time required to test different iterations Rolando Garcia Sanchez created FLOR which is a library that automatically checkpoints training epochs and instruments your code so that you can bypass early training cycles when y

May 2, 2022 • 46:31

Automatically Enforce Software Structures With Powerful Code Modifications Powered By LibCST

Summary Programmers love to automate tedious processes, including refactoring your code. In order to support the creation of code modifications for your Python projects Jimmy Lai created LibCST. It provides a richly typed and high level API for creating and manipulating concrete syntax trees of your source code. In this episode Jimmy Lai and Zsolt Dollenstein explain how it works, some of the linting and automatic code modification utilities that you can build with it and how to get started with

Apr 25, 2022 • 56:48

Cloud Native Networking For Developers With The Gloo Platform

Summary Communication is a fundamental requirement for any program or application. As the friction involved in deploying code has gone down, the motivation for architecting your system as microservices goes up. This shifts the communication patterns in your software from function calls to network calls. In this episode Idit Levine explains how the Gloo platform that she and her team at Solo have created makes it easier for you to configure and monitor the network topologies for your microservice

Apr 19, 2022 • 50:34

Accelerate And Simplify Cloud Native Development For Kubernetes Environments With Gefyra

Summary Cloud native architectures have been gaining prominence for the past few years due to the rising popularity of Kubernetes. This introduces new complications to development workflows due to the need to integrate with multiple services as you build new components for your production systems. In order to reduce the friction involved in developing applications for cloud native environments Michael Schilonka created Gefyra. In this episode he explains how it connects your local machine to a r

Apr 11, 2022 • 38:14

Building A Community And Technology Stack For Scalable Big Data Geoscience At Pangeo

Summary Science is founded on the collection and analysis of data. For disciplines that rely on data about the earth the ability to simulate and generate that data has been growing faster than the tools for analysis of that data can keep up with. In order to help scale that capacity for everyone working in geosciences the Pangeo project compiled a reference stack that combines powerful tools into an out-of-the-box solution for researchers to be productive in short order. In this episode Ryan Abe

Mar 28, 2022 • 52:08

Automating Application Lifecycles For Developer Happiness At Wayfair

Summary A common piece of advice when starting anything new is to "begin with the end in mind". In order to help the engineers at Wayfair manage the complete lifecycle of their applications Joshua Woodward runs a team that provides tooling and assistance along every step of the journey. In this episode he shares some of the lessons and tactics that they have developed while assisting other engineering teams with starting, deploying, and sunsetting projects. This is an interesting look

Mar 20, 2022 • 46:12

Run Your Applications Reliably On Kubernetes Without Losing Sleep With Robusta

Summary Kubernetes is a framework that aims to simplify the work of running applications in production, but it forces you to adopt new patterns for debugging and resolving issues in your systems. Robusta is aimed at making that a more pleasant experience for developers and operators through pre-built automations, easy debugging, and a simple means of creating your own event-based workflows to find, fix, and alert on errors in production. In this episode Natan Yellin explains how the project got

Mar 14, 2022 • 53:43

Accelerate The Development And Delivery Of Your Machine Learning Applications Using Ray And Deploy It At Anyscale

Summary Building a machine learning application is inherently complex. Once it becomes necessary to scale the operation or training of the model, or introduce online re-training the process becomes even more challenging. In order to reduce the operational burden of AI developers Robert Nishihara helped to create the Ray framework that handles the distributed computing aspects of machine learning operations. To support the ongoing development and simplify adoption of Ray he co-founded Anyscale. I

Mar 6, 2022 • 45:58

See The Structure Of Your Software At A Glance With Call Graphs From Code2Flow

Summary As software projects grow and change it can become difficult to keep track of all of the logical flows. By visualizing the interconnections of function definitions, classes, and their invocations you can speed up the time to comprehension for newcomers to a project, or help yourself remember what you worked on last month. In this episode Scott Rogowski shares his work on Code2Flow as a way to generate a call graph of your programs. He explains how it got started, how it works, and how yo

Feb 28, 2022 • 45:35

Scaling Knowledge Management For Technical Teams With Knowledge Repo

Summary One of the most persistent challenges faced by organizations of all sizes is the recording and distribution of institutional knowledge. In technical teams this is exacerbated by the need to incorporate technical review feedback and manage access to data before publishing. When faced with this problem as an early data scientist at AirBnB, Chetan Sharma helped create the Knowledge Repo project as a solution. In this episode he shares the story behind its creation and growth, how and why it

Feb 21, 2022 • 39:35

Simplify And Scale Your Software Development Cycles By Putting On Pants (Build Tool)

Summary Software development is a complex undertaking due to the number of options available and choices to be made in every stage of the lifecycle. In order to make it more scaleable it is necessary to establish common practices and patterns and introduce strong opinions. One area that can have a huge impact on the productivity of the engineers engaged with a project is the tooling used for building, validating, and deploying changes introduced to the software. In this episode maintainers of th

Feb 14, 2022 • 58:15

Achieve Repeatable Builds Of Your Software On Any Machine With Earthly

Summary It doesn’t matter how amazing your application is if you are unable to deliver it to your users. Frustrated with the rampant complexity involved in building and deploying software Vlad A. Ionescu created the Earthly tool to reduce the toil involved in creating repeatable software builds. In this episode he explains the complexities that are inherent to building software projects and how he designed the syntax and structure of Earthly to make it easy to adopt for developers across a

Feb 6, 2022 • 54:01

Building A Detailed View Of Your Software Delivery Process With The Eiffel Protocol

Summary The process of getting software delivered to an environment where users can interact with it requires many steps along the way. In some cases the journey can require a large number of interdependent workflows that need to be orchestrated across technical and organizational boundaries, making it difficult to know what the current status is. Faced with such a complex delivery workflow the engineers at Ericsson created a message based protocol and accompanying tooling to let the various act

Jan 31, 2022 • 49:54

Improve Your Productivity By Investing In Developer Experience Design For Your Projects

Summary When we are creating applications we spend a significant amount of effort on optimizing the experience of our end users to ensure that they are able to complete the tasks that the system is intended for. A similar effort that we should all consider is optimizing the developer experience for ourselves and other engineers who contribute to the projects that we work on. Adam Johnson recently wrote a book on how to improve the developer experience for Django projects and in this episode he s

Jan 24, 2022 • 42:54

An Exploration Of Effective Pandas Practices With Matt Harrison

Summary Pandas has grown to be a ubiquitous tool for working with data at every stage. It has become so well known that many people learn Python solely for the purpose of using Pandas. With all of this activity and the long history of the project it can be easy to find misleading or outdated information about how to use it. In this episode Matt Harrison shares his work on the book "Effective Pandas" and some of the best practices and potential pitfalls that you should know for applying

Jan 15, 2022 • 49:57

Generate Your Text Files With Python Using Cog

Summary Developers hate wasting effort on manual processes when we can write code to do it instead. Cog is a tool to manage the work of automating the creation of text inside another file by executing arbitrary Python code. In this episode Ned Batchelder shares the story of why he created Cog in the first place, some of the interesting ways that he uses it in his daily work, and the unique challenges of maintaining a project with a small audience and a well defined scope. Announcements Hello an

Jan 13, 2022 • 50:33

A Friendly Approach To Regression Models For Programmers

Summary Statistical regression models are a staple of predictive forecasts in a wide range of applications. In this episode Matthew Rudd explains the various types of regression models, when to use them, and his work on the book "Regression: A Friendly Guide" to help programmers add regression techniques to their toolbox. Announcements Hello and welcome to Podcast.__init__, the podcast about Python’s role in data and science. When you’re ready to launch your next app or wa

Jan 2, 2022 • 45:15

Fast, Flexible, and Incremental Task Automation With doit

Summary Every software project needs a tool for managing the repetitive tasks that are involved in building, running, and deploying the code. Frustrated with the limitations of tools like Make, Scons, and others Eduardo Schettino created doit to handle task automation in his own work and released it as open source. In this episode he shares the story behind the project, how it is implemented under the hood, and how you can start using it in your own projects to save you time and effort. Announce

Dec 27, 2021 • 39:27

The Technological, Business, and Sales Challenges Of Building The Ethical Ads Network

Summary Whether we like it or not, advertising is a common and effective way to make money on the internet. In order to support the work being done at Read The Docs they decided to include advertisements on the documentation sites they were hosting, but they didn’t want to alienate their users or collect unnecessary information. In this episode David Fischer explains how they built the Ethical Ads network to solve their problem, the technical and business challenges that are involved, and

Dec 20, 2021 • 55:49

Accidentally Building A Business With Python At Listen Notes

Summary Podcasts are one of the few mediums in the internet era that are still distributed through an open ecosystem. This has a number of benefits, but it also brings the challenge of making it difficult to find the content that you are looking for. Frustrated by the inability to pick and choose single episodes across various shows for his listening Wenbin Fang started the Listen Notes project to fulfill his own needs. He ended up turning that project into his full time business which has grown

Dec 12, 2021 • 43:29

Making Orbital Mechanics More Accessible With Poliastro

Summary Outer space holds a deep fascination for people of all ages, and the key principle in its exploration both near and far is orbital mechanics. Poliastro is a pure Python package for exploring and simulating orbit calculations. In this episode Juan Luis Cano Rodriguez shares the story behind the project, how you can use it to learn more about space travel, and some of the interesting projects that have used it for planning planetary and interplanetary missions. Announcements Hello and wel

Nov 27, 2021 • 59:00

Declarative Deep Learning From Your Laptop To Production With Ludwig and Horovod

Summary Deep learning frameworks encourage you to focus on the structure of your model ahead of the data that you are working with. Ludwig is a tool that uses a data oriented approach to building and training deep learning models so that you can experiment faster based on the information that you actually have, rather than spending all of our time manipulating features to make them match your inputs. In this episode Travis Addair explains how Ludwig is designed to improve the adoption of deep le

Nov 22, 2021 • 1:04:48

Build Better Analytics And Models With A Focus On The Data Experience

Summary A lot of time and energy goes into data analysis and machine learning projects to address various goals. Most of the effort is focused on the technical aspects and validating the results, but how much time do you spend on considering the experience of the people who are using the outputs of these projects? In this episode Benn Stancil explores the impact that our technical focus has on the perceived value of our work, and how taking the time to consider what the desired experience will b

Nov 22, 2021 • 59:28

Building Conversational AI to Augment Sales Teams at Structurely

Summary The true power of artificial intelligence is its ability to work collaboratively with humans. Nate Joens co-founded Structurely to create a conversational AI platform that augments human sales teams to help guide potential customers through the initial steps of the funnel. In this episode he discusses the technical and social considerations that need to be combined for a seamless conversational experience and how he and his team are tackling the problem. Announcements Hello and welcome

Nov 6, 2021 • 51:00

Build Composable And Reusable Feature Engineering Pipelines with Feature-Engine

Summary Every machine learning model has to start with feature engineering. This is the process of combining input variables into a more meaningful signal for the problem that you are trying to solve. Many times this process can lead to duplicating code from previous projects, or introducing technical debt in the form of poorly maintained feature pipelines. In order to make the practice more manageable Soledad Galli created the feature-engine library. In this episode she explains how it has help

Oct 31, 2021 • 53:29

Speed Up Your Python Data Applications By Parallelizing Them With Bodo

Summary The speed of Python is a subject of constant debate, but there is no denying that for compute heavy work it is not the optimal tool. Rather than rewriting your data oriented applications, or having to rearchitect them, the team at Bodo wrote a compiler that will do the optimization for you. In this episode Ehsan Totoni explains how they are able to translate pure Python into massively parallel processes that are optimized for high performance compute systems. Announcements Hello and wel

Oct 25, 2021 • 58:07

An Exploration Of Financial Exchange Risk Management Strategies

Summary The world of finance has driven the development of many sophisticated techniques for data analysis. In this episode Paul Stafford shares his experiences working in the realm of risk management for financial exchanges. He discusses the types of risk that are involved, the statistical methods that he has found most useful for identifying strategies to mitigate that risk, and the software libraries that have helped him most in his work. Announcements Hello and welcome to the Data Engineeri

Oct 16, 2021 • 34:30

Build Better Machine Learning Models By Understanding Their Decisions With SHAP

Summary Machine learning and deep learning techniques are powerful tools for a large and growing number of applications. Unfortunately, it is difficult or impossible to understand the reasons for the answers that they give to the questions they are asked. In order to help shine some light on what information is being used to provide the outputs to your machine learning models Scott Lundberg created the SHAP project. In this episode he explains how it can be used to provide insight into which fea

Oct 9, 2021 • 1:04:54

Accelerating Drug Discovery Using Machine Learning With TorchDrug

Summary Finding new and effective treatments for disease is a complex and time consuming endeavor, requiring a high degree of domain knowledge and specialized equipment. Combining his expertise in machine learning and graph algorithms with is interest in drug discovery Jian Tang created the TorchDrug project to help reduce the amount of time needed to find new candidate molecules for testing. In this episode he explains how the project is being used by machine learning researchers and biochemist

Sep 30, 2021 • 44:31

An Exploration Of Automated Speech Recognition

Summary The overwhelming growth of smartphones, smart speakers, and spoken word content has corresponded with increasingly sophisticated machine learning models for recognizing speech content in audio data. Dylan Fox founded Assembly to provide access to the most advanced automated speech recognition models for developers to incorporate into their own products. In this episode he gives an overview of the current state of the art for automated speech recognition, the varying requirements for accu

Sep 26, 2021 • 54:01

Experimenting With Reinforcement Learning Using MushroomRL

Summary Reinforcement learning is a branch of machine learning and AI that has a lot of promise for applications that need to evolve with changes to their inputs. To support the research happening in the field, including applications for robotics, Carlo D’Eramo and Davide Tateo created MushroomRL. In this episode they share how they have designed the project to be easy to work with, so that students can use it in their study, as well as extensible so that it can be used by businesses and i

Sep 19, 2021 • 54:18

Doing Dask Powered Data Science In The Saturn Cloud

Summary A perennial problem of doing data science is that it works great on your laptop, until it doesn’t. Another problem is being able to recreate your environment to collaborate on a problem with colleagues. Saturn Cloud aims to help with both of those problems by providing an easy to use platform for creating reproducible environments that you can use to build data science workflows and scale them easily with a managed Dask service. In this episode Julia Signall, head of open source at

Sep 10, 2021 • 38:01

Monitor The Health Of Your Machine Learning Products In Production With Evidently

Summary You’ve got a machine learning model trained and running in production, but that’s only half of the battle. Are you certain that it is still serving the predictions that you tested? Are the inputs within the range of tolerance that you designed? Monitoring machine learning products is an essential step of the story so that you know when it needs to be retrained against new data, or parameters need to be adjusted. In this episode Emeli Dral shares the work that she and her team

Sep 3, 2021 • 50:59

Making Automated Machine Learning More Accessible With EvalML

Summary Building a machine learning model is a process that requires a lot of iteration and trial and error. For certain classes of problem a large portion of the searching and tuning can be automated. This allows data scientists to focus their time on more complex or valuable projects, as well as opening the door for non-specialists to experiment with machine learning. Frustrated with some of the awkward or difficult to use tools for AutoML, Angela Lin and Jeremy Shih helped to create the EvalM

Aug 25, 2021 • 45:53

Growing And Supporting The Data Science Community At Anaconda

Summary Data scientists are tasked with answering challenging questions using data that is often messy and incomplete. Anaconda is on a mission to make the lives of data professionals more manageable through creation and maintenance of high quality libraries and frameworks, the distribution of an easy to use Python distribution and package ecosystem, and high quality training material. In this episode Kevin Goldsmith, CTO of Anaconda, discusses the technical and social challenges faced by data s

Aug 19, 2021 • 55:49

Making Automated Machine Learning More Accessible With EvalML

Building a machine learning model is a process that requires a lot of iteration and trial and error. For certain classes of problem a large portion of the searching and tuning can be automated. This allows data scientists to focus their time on more complex or valuable projects, as well as opening the door for non-specialists to experiment with machine learning. Frustrated with some of the awkward or difficult to use tools for AutoML, Angela Lin and Jeremy Shih helped to create the EvalML framew

Aug 19, 2021 • 55:48

Network Analysis At The Speed Of C With The Power Of Python Using NetworKit

Summary Analysing networks is a growing area of research in academia and industry. In order to be able to answer questions about large or complex relationships it is necessary to have fast and efficient algorithms that can process the data quickly. In this episode Eugenio Angriman discusses his contributions to the NetworKit library to provide an accessible interface for these algorithms. He shares how he is using NetworKit for his own research, the challenges of working with large and complex n

Aug 15, 2021 • 37:07

Delivering Deep Learning Powered Speech Recognition As A Service For Developers At AssemblyAI

Summary Building a software-as-a-service (SaaS) business is a fairly well understood pattern at this point. When the core of the service is a set of machine learning products it introduces a whole new set of challenges. In this episode Dylan Fox shares his experience building Assembly AI as a reliable and affordable option for automatic speech recognition that caters to a developer audience. He discusses the machine learning development and deployment processes that his team relies on, the scala

Aug 4, 2021 • 52:21

Taking Aim At The Legacy Of SQL With The Preql Relational Language

Summary SQL has gone through many cycles of popularity and disfavor. Despite its longevity it is objectively challenging to work with in a collaborative and composable manner. In order to address these shortcomings and build a new interface for your database oriented workloads Erez Shinan created Preql. It is based on the same relational algebra that inspired SQL, but brings in more robust computer science principles to make it more manageable as you scale in complexity. In this episode he share

Jul 28, 2021 • 36:39

Unleash The Power Of Dataframes At Any Scale With Modin

Summary When you start working on a data project there are always a variety of unknown factors that you have to explore. One of those is the volume of total data that you will eventually need to handle, and the speed and scale at which it will need to be processed. If you optimize for scale too early then it adds a high barrier to entry due to the complexities of distributed systems, but if you invest in a lot of engineering up front then it can be challenging to refactor for scale. Modin is a p

Jul 22, 2021 • 38:54

Exploring The SpeechBrain Toolkit For Speech Processing

Summary With the rising availability of computation in everyday devices, there has been a corresponding increase in the appetite for voice as the primary interface. To accomodate this desire it is necessary for us to have high quality libraries for being able to process and generate audio data that can make sense of human speech. To facilitate research and industry applications for speech data Mirco Ravanelli and Peter Plantinga are building SpeechBrain. In this episode they explain how it works

Jul 14, 2021 • 37:27

Fast And Educational Exploration And Analysis Of Graph Data Structures With graph-tool

Summary If you are interested in a library for working with graph structures that will also help you learn more about the research and theory behind the algorithms then look no further than graph-tool. In this episode Tiago Peixoto shares his work on graph algorithms and networked data and how he has built graph-tool to help in that research. He explains how it is implemented, how it evolved from a simple command line tool to a full-fledged library, and the benefits that he has found from buildi

Jul 7, 2021 • 42:00

Lightening The Load For Deep Learning With Sparse Networks Using Neural Magic

Summary Deep learning has largely taken over the research and applications of artificial intelligence, with some truly impressive results. The challenge that it presents is that for reasonable speed and performance it requires specialized hardware, generally in the form of a dedicated GPU (Graphics Processing Unit). This raises the cost of the infrastructure, adds deployment complexity, and drastically increases the energy requirements for training and serving of models. To address these challen

Jun 30, 2021 • 48:33

Finding The Core Of Python For A Bright Future With Brett Cannon

Summary Brett Cannon has been a long-time contributor to the Python language and community in many ways. In this episode he shares some of his work and thoughts on modernizing the ecosystem around the language. This includes standards for packaging, discovering the true core of the language, and how to make it possible to target mobile and web platforms. Announcements Hello and welcome to Podcast.__init__, the podcast about Python’s role in data and science. When you’re ready to lau

Jun 23, 2021 • 1:03:19

Traversing The Challenges And Promise Of Graph Machine Learning

Summary The foundation of every ML model is the data that it is trained on. In many cases you will be working with tabular or unstructured information, but there is a growing trend toward networked, or graph data sets. Benedek Rozemberczki has focused his research and career around graph machine learning applications. In this episode he discusses the common sources of networked data, the challenges of working with graph data in machine learning projects, and describes the libraries that he has c

Jun 16, 2021 • 47:47

Keep Your Analytics Lint Free With SQLFluff

Summary The growth of analytics has accelerated the use of SQL as a first class language. It has also grown the amount of collaboration involved in writing and maintaining SQL queries. With collaboration comes the inevitable variation in how queries are written, both structurally and stylistically which can lead to a significant amount of wasted time and energy during code review and employee onboarding. Alan Cruickshank was feeling the pain of this wasted effort first-hand which led him down th

Jun 9, 2021 • 1:13:14

Exploring The Patterns And Practices For Deep Learning With Andrew Ferlitsch

Summary Deep learning is gaining an immense amount of popularity due to the incredible results that it is able to offer with comparatively little effort. Because of this there are a number of engineers who are trying their hand at building machine learning models with the wealth of frameworks that are available. Andrew Ferlitsch wrote a book to capture the useful patterns and best practices for building models with deep learning to make it more approachable for newcomers ot the field. In this ep

Jun 2, 2021 • 44:19

Automatically Generate Your Unit Tests From Scratch With Pynguin

Summary Unit tests are an important tool to ensure the proper functioning of your application, but writing them can be a chore. Stephan Lukasczyk wants to reduce the monotony of the process for Python developers. As part of his PhD research he created the Pynguin project to automate the creation of unit tests. In this episode he explains the complexity involved in generating useful tests for a dynamic language, how he has designed Pynguin to address the challenges, and how you can start using it

May 25, 2021 • 57:41

Leveling Up Natural Language Processing with Transfer Learning

Summary Natural language processing is a powerful tool for extracting insights from large volumes of text. With the growth of the internet and social platforms, and the increasing number of people and communities conducting their professional and personal activities online, the opportunities for NLP to create amazing insights and experiences are endless. In order to work with such a large and growing corpus it has become necessary to move beyond purely statistical methods and embrace the capabil

May 18, 2021 • 46:34

Federated Learning For All With Flower

Summary Machine learning is a tool that has typically been performed on large volumes of data in one place. As more computing happens at the edge on mobile and low power devices, the learning is being federated which brings a new set of challenges. Daniel Beutel co-created the Flower framework to make federated learning more manageable. In this episode he shares his motivations for starting the project, how you can use it for your own work, and the unique challenges and benefits that this emergi

May 11, 2021 • 1:01:29

Data Exploration and Visualization Made Effortless with Lux

Summary Data exploration is an important step in any analysis or machine learning project. Visualizing the data that you are working with makes that exploration faster and more effective, but having to remember and write all of the code to build a scatter plot or histogram is tedious and time consuming. In order to eliminate that friction Doris Lee helped create the Lux project, which wraps your Pandas data frame and automatically generates a set of visualizations without you having to lift a fi

May 4, 2021 • 51:05

Extensible Open Source Authorization For Your Applications With Oso

Summary Any project that is used by more than one person will eventually need to handle permissions for each of those users. It is certainly possible to write that logic yourself, but you’ll almost certainly do it wrong at least once. Rather than waste your time fighting with bugs in your authorization code it makes sense to use a well-maintained library that has already made and fixed all of the mistakes so that you don’t have to. In this episode Sam Scott shares the Oso framework t

Apr 27, 2021 • 51:49

Teaching Geeks The Value And Skills Of Public Speaking

Summary Being able to present your ideas is one of the most valuable and powerful skills to have as a professional, regardless of your industry. For software engineers it is especially important to be able to communicate clearly and effectively because of the detail-oriented nature of the work. Unfortunately, many people who work in software are more comfortable in front of the keyboard than a crowd. In this episode Neil Thompson shares his story of being an accidental public speaker and how he

Apr 20, 2021 • 42:54

Let The Robots Do The Work Using Robotic Process Automation with Robocorp

Summary One of the great promises of computers is that they will make our work faster and easier, so why do we all spend so much time manually copying data from websites, or entering information into web forms, or any of the other tedious tasks that take up our time? As developers our first inclination is to "just write a script" to automate things, but how do you share that with your non-technical co-workers? In this episode Antti Karjalainen, CEO and co-founder of Robocorp, explains

Apr 13, 2021 • 45:34

Keep Your Code Clean And Maintainable Using Static Analysis With Flake8

Summary When you are writing code it is all to easy to introduce subtle bugs or leave behind unused code. Unused variables, unused imports, overly complex logic, etc. If you are careful and diligent you can find these problems yourself, but isn’t that what computers are supposed to help you with? Thankfully Python has a wealth of tools that will work with you to keep your code clean and maintainable. In this episode Anthony Sottile explores Flake8, one of the most popular options for ident

Apr 6, 2021 • 49:32

Make Your Code More Readable With The Magic Of Refactoring Using Sourcery

Summary Writing code that is easy to read and understand will have a lasting impact on you and your teammates over the life of a project. Sometimes it can be difficult to identify opportunities for simplifying a block of code, especially if you are early in your journey as a developer. If you work with senior engineers they can help by pointing out ways to refactor your code to be more readable, but they aren’t always available. Brendan Maginnis and Nick Thapen created Sourcery to act as a

Mar 30, 2021 • 1:00:58

Be Data Driven At Any Scale With Superset

Summary Becoming data driven is the stated goal of a large and growing number of organizations. In order to achieve that mission they need a reliable and scalable method of accessing and analyzing the data that they have. While business intelligence solutions have been around for ages, they don’t all work well with the systems that we rely on today and a majority of them are not open source. Superset is a Python powered platform for exploring your data and building rich interactive dashboa

Mar 22, 2021 • 47:33

Practical Advice On Using Python To Power A Business

Summary Python is a language that is used in almost every imaginable context and by people from an amazing range of backgrounds. A lot of the people who use it wouldn’t even call themselves programmers, because that is not the primary focus of their job. In this episode Chris Moffitt shares his experience writing Python as a business user. In order to share his insights and help others who have run up against the limits of Excel he maintains the site Practical Business Python where he publ

Mar 16, 2021 • 49:30

Analyzing The Ecosystem of Python Data Companies With Tony Liu

Summary There are a large and growing number of businesses built by and for data science and machine learning teams that rely on Python. Tony Liu is a venture investor who is following that market closely and betting on its continued success. In this episode he shares his own journey into the role of an investor and discusses what he is most excited about in the industry. He also explains what he looks at when investing in a business and gives advice on what potential founders and early employee

Mar 9, 2021 • 39:31

Go From Notebook To Pipeline For Your Data Science Projects With Orchest

Summary Jupyter notebooks are a dominant tool for data scientists, but they lack a number of conveniences for building reusable and maintainable systems. For machine learning projects in particular there is a need for being able to pivot from exploring a particular dataset or problem to integrating that solution into a larger workflow. Rick Lamers and Yannick Perrenet were tired of struggling with one-off solutions when they created the Orchest platform. In this episode they explain how Orchest

Mar 2, 2021 • 44:24

Write Your Python Scripts In A Flow Based Visual Editor With Ryven

Summary When you are writing a script it can become unwieldy to understand how the logic and data are flowing through the program. To make this easier to follow you can use a flow-based approach to building your programs. Leonn Thomm created the Ryven project as an environment for visually constructing a flow-based program. In this episode he shares his inspiration for creating the Ryven project, how it changes the way you think about program design, how Ryven is implemented, and how to get star

Feb 23, 2021 • 47:21

CrossHair: Your Automatic Pair Programmer

Summary One of the perennial challenges in software engineering is to reduce the opportunity for bugs to creep into the system. Some of the tools in our arsenal that help in this endeavor include rich type systems, static analysis, writing tests, well defined interfaces, and linting. Phillip Schanely created the CrossHair project in order to add another ally in the fight against broken code. It sits somewhere between type systems, automated test generation, and static analysis. In this episode h

Feb 16, 2021 • 42:54

Giving Your Data Science Projects And Teams A Home At DagsHub

Summary Collaborating on software projects is largely a solved problem, with a variety of hosted or self-managed platforms to choose from. For data science projects, collaboration is still an open question. There are a number of projects that aim to bring collaboration to data science, but they are all solving a different aspect of the problem. Dean Pleban and Guy Smoilovsky created DagsHub to give individuals and teams a place to store and version their code, data, and models. In this episode t

Feb 9, 2021 • 59:20

Exploring Literate Programming For Python Projects With nbdev

Summary Creating well designed software is largely a problem of context and understanding. The majority of programming environments rely on documentation, tests, and code being logically separated despite being contextually linked. In order to weave all of these concerns together there have been many efforts to create a literate programming environment. In this episode Jeremy Howard of fast.ai fame and Hamel Husain of GitHub share the work they have done on nbdev. The explain how it allows you t

Feb 2, 2021 • 51:39

Making The Sans I/O Ideal A Reality For The Websockets Library

Summary Working with network protocols is a common need for software projects, particularly in the current age of the internet. As a result, there are a multitude of libraries that provide interfaces to the various protocols. The problem is that implementing a network protocol properly and handling all of the edge cases is hard, and most of the available libraries are bound to a particular I/O paradigm which prevents them from being widely reused. To address this shortcoming there has been a mov

Jan 26, 2021 • 38:04

Driving Toward A Faster Python Interpreter With Pyston

Summary One of the common complaints about Python is that it is slow. There are languages and runtimes that can execute code faster, but they are not as easy to be productive with, so many people are willing to make that tradeoff. There are some use cases, however, that truly need the benefit of faster execution. To address this problem Kevin Modzelewski helped to create the Pyston intepreter that is focused on speeding up unmodified Python code. In this episode he shares the history of the proj

Jan 19, 2021 • 44:07

Project Scaffolding That Evolves With Your Software Using Copier

Summary Every software project has a certain amount of boilerplate to handle things like linting rules, test configuration, and packaging. Rather than recreate everything manually every time you start a new project you can use a utility to generate all of the necessary scaffolding from a template. This allows you to extract best practices and team standards into a reusable project that will save you time. The Copier project is one such utility that goes above and beyond the bare minimum by suppo

Jan 12, 2021 • 57:57

How Python's Evolution Impacts Your Fluency With Luciano Ramalho

Summary On its surface Python is a simple language which is what has contributed to its rise in popularity. As you move to intermediate and advanced usage you will find a number of interesting and elegant design elements that will let you build scalable and maintainable systems and design friendly interfaces. Luciano Ramalho is best known as the author of Fluent Python which has quickly become a leading resource for Python developers to increase their facility with the language. In this episode

Jan 5, 2021 • 1:00:13

Making Content Management A Smooth Experience With A Headless CMS

Summary Building a web application requires integrating a number of separate concerns into a single experience. One of the common requirements is a content management system to allow product owners and marketers to make the changes needed for them to do their jobs. Rather than spend the time and focus of your developers to build the end to end system a growing trend is to use a headless CMS. In this episode Jake Lumetta shares why he decided to spend his time and energy on building a headless CM

Dec 28, 2020 • 48:51

Turning Notebooks Into Collaborative And Dynamic Data Applications With Hex

Summary Notebooks have been a useful tool for analytics, exploratory programming, and shareable data science for years, and their popularity is continuing to grow. Despite their widespread use, there are still a number of challenges that inhibit collaboration and use by non-technical stakeholders. Barry McCardel and his team at Hex have built a platform to make collaboration on Jupyter notebooks a first class experience, as well as allowing notebooks to be parameterized and exposing the logic th

Dec 21, 2020 • 42:39

Add Anomaly Detection To Your Time Series Data With Luminaire

Summary When working with data it’s important to understand when it is correct. If there is a time dimension, then it can be difficult to know when variation is normal. Anomaly detection is a useful tool to address these challenges, but a difficult one to do well. In this episode Smit Shah and Sayan Chakraborty share the work they have done on Luminaire to make anomaly detection easier to work with. They explain the complexities inherent to working with time series data, the strategies tha

Dec 15, 2020 • 54:24

Building Big Data Pipelines For Audio With Klio

Summary Technologies for building data pipelines have been around for decades, with many mature options for a variety of workloads. However, most of those tools are focused on processing of text based data, both structured and unstructured. For projects that need to manage large numbers of binary and audio files the list of options is much shorter. In this episode Lynn Root shares the work that she and her team at Spotify have done on the Klio project to make that list a bit longer. She discusse

Dec 7, 2020 • 53:37

Open Sourcing The Anvil Full Stack Python Web App Platform

Summary Building a complete web application requires expertise in a wide range of disciplines. As a result it is often the work of a whole team of engineers to get a new project from idea to production. Meredydd Luff and his co-founder built the Anvil platform to make it possible to build full stack applications entirely in Python. In this episode he explains why they released the application server as open source, how you can use it to run your own projects for free, and why developer tooling i

Dec 1, 2020 • 51:23

Pants Has Got Your Python Monorepo Covered

Summary In a software project writing code is just one step of the overall lifecycle. There are many repetitive steps such as linting, running tests, and packaging that need to be run for each project that you maintain. In order to reduce the overhead of these repeat tasks, and to simplify the process of integrating code across multiple systems the use of monorepos has been growing in popularity. The Pants build tool is purpose built for addressing all of the drudgery and for working with monore

Nov 23, 2020 • 51:39

Scale Your Data Science Teams With Machine Learning Operations Principles

Summary Building a machine learning model is a process that requires well curated and cleaned data and a lot of experimentation. Doing it repeatably and at scale with a team requires a way to share your discoveries with your teammates. This has led to a new set of operational ML platforms. In this episode Michael Del Balso shares the lessons that he learned from building the platform at Uber for putting machine learning into production. He also explains how the feature store is becoming the core

Nov 17, 2020 • 51:58

Making The Case For A (Semi) Formal Specification Of CPython

Summary The CPython implementation has grown and evolved significantly over the past ~25 years. In that time there have been many other projects to create compatible runtimes for your Python code. One of the challenges for these other projects is the lack of a fully documented specification of how and why everything works the way that it does. In the most recent Python language summit Mark Shannon proposed implementing a formal specification for CPython, and in this episode he shares his reasoni

Nov 10, 2020 • 36:41

Bringing Artificial Intelligence Projects From Idea To Production

Summary Artificial intelligence applications can provide dramatic benefits to a business, but only if you can bring them from idea to production. Henrik Landgren was behind the original efforts at Spotify to leverage data for new product features, and in his current role he works on an AI system to evaluate new businesses to invest in. In this episode he shares advice on how to identify opportunities for leveraging AI to improve your business, the capabilities necessary to enable aa successful p

Nov 3, 2020 • 47:49

Power Up Your Java Using Python With JPype

Summary Python and Java are two of the most popular programming languages in the world, and have both been around for over 20 years. In that time there have been numerous attempts to provide interoperability between them, with varying methods and levels of success. One such project is JPype, which allows you to use Java classes in your Python code. In this episode the current lead developer, Karl Nelson, explains why he chose it as his preferred tool for combining these ecosystems, how he and hi

Oct 26, 2020 • 48:40

The Journey To Replace Python's Parser And What It Means For The Future

Summary The release of Python 3.9 introduced a new parser that paves the way for brand new features. Every programming language has its own specific syntax for representing the logic that you are trying to express. The way that the rules of the language are defined and validated is with a grammar definition, which in turn is processed by a parser. The parser that the Python language has relied on for the past 25 years has begun to show its age through mounting technical debt and a lack of flexib

Oct 19, 2020 • 1:05:49

Cloud Native Application Delivery Using GitOps

Summary The way that applications are being built and delivered has changed dramatically in recent years with the growing trend toward cloud native software. As part of this movement toward the infrastructure and orchestration that powers your project being defined in software, a new approach to operations is gaining prominence. Commonly called GitOps, the main principle is that all of your automation code lives in version control and is executed automatically as changes are merged. In this epis

Oct 12, 2020 • 53:44

Threading The Needle Of Interesting And Informative While You Learn To Code

Summary Learning to code is a neverending journey, which is why it’s important to find a way to stay motivated. A common refrain is to just find a project that you’re interested in building and use that goal to keep you on track. The problem with that advice is that as a new programmer, you don’t have the knowledge required to know which projects are reasonable, which are difficult, and which are effectively impossible. Steven Lott has been sharing his programming expertise as

Oct 6, 2020 • 56:30

Solving Python Package Creation For End User Applications With PyOxidizer

Summary Python is a powerful and expressive programming language with a vast ecosystem of incredible applications. Unfortunately, it has always been challenging to share those applications with non-technical end users. Gregory Szorc set out to solve the problem of how to put your code on someone else’s computer and have it run without having to rely on extra systems such as virtualenvs or Docker. In this episode he shares his work on PyOxidizer and how it allows you to build a self-contain

Sep 29, 2020 • 49:40

Flexible Network Security Detection And Response With Grapl

Summary Servers and services that have any exposure to the public internet are under a constant barrage of attacks. Network security engineers are tasked with discovering and addressing any potential breaches to their systems, which is a never-ending task as attackers continually evolve their tactics. In order to gain better visibility into complex exploits Colin O’Brien built the Grapl platform, using graph database technology to more easily discover relationships between activities withi

Sep 22, 2020 • 53:32

Simplified Data Extraction And Analysis For Current Events With Newspaper

Summary News media is an important source of information for understanding the context of the world. To make it easier to access and process the contents of news sites Lucas Ou-Yang built the Newspaper library that aids in automatic retrieval of articles and prepare it for analysis. In this episode he shares how the project got started, how it is implemented, and how you can get started with it today. He also discusses how recent improvements in the utility and ease of use of deep learning libra

Sep 15, 2020 • 43:28

Digging Into Dagster: An Opinionated Open Source Framework For Data Orchestration

Summary Data applications are complex and continually evolving, often requiring collaboration across multiple teams. In order to keep everyone on the same page a high level abstraction is needed to facilitate a cross-cutting view of the data orchestration across integration, transformation, analytics, and machine learning. Dagster is an innovative new framework that leans on the power and flexibility of Python to provide an extensible interface to the complete lifecycle of data projects. In this

Sep 7, 2020 • 59:28

When, Why, and How To Use Web Scraping In A Nutshell

Summary The internet is a rich source of information, but a majority of it isn’t accessible programmatically through APIs or databases. To address that shortcoming there are a variety of web scraping frameworks that aid in extracting structured data from web pages. In this episode Attila Tóth shares the challenges of web data extraction, the ways that you can use it, and how Scrapy and ScrapingHub can help you with your projects. Announcements Hello and welcome to Podcast.__init__, the po

Sep 1, 2020 • 41:52

Working In The Code Mines: Mining Software Repositories With PyDriller

Summary A large portion of the software industry has standardized on Git as the version control sytem of choice. But have you thought about all of the information that you are generating with your branches, commits, and code changes? Davide Spadini created the PyDriller framework to simplify the work of mining software repositories to perform research on the technical and social aspects of software engineering. In this episode he shares some of the insights that you can gain by exploring the his

Aug 25, 2020 • 40:03

Building The Open Data Ecosystem For Music And More At Metabrainz

Summary The Musicbrainz project was an early entry in the movement to build an open data ecosystem. In recent years, the Metabrainz Foundation has fostered a growing ecosystem of projects to support the contribution of, and access to, metadata, listening habits, and review of music. The majority of those projects are written in Python, and in this episode Param Singh explains how they are built, how they fit together, and how they support the goals of the Metabrains Foundation. This was an inter

Aug 17, 2020 • 48:06

Growing Dask To Make Scaling Python Data Science Easier At Coiled

Summary Python is a leading choice for data science due to the immense number of libraries and frameworks readily available to support it, but it is still difficult to scale. Dask is a framework designed to transparently run your data analysis across multiple CPU cores and multiple servers. Using Dask lifts a limitation for scaling your analytical workloads, but brings with it the complexity of server administration, deployment, and security. In this episode Matthew Rocklin and Hugo Bowne-Anders

Aug 10, 2020 • 52:07

Supporting The Full Lifecycle Of Machine Learning Projects With Metaflow

Summary Netflix uses machine learning to power every aspect of their business. To do this effectively they have had to build extensive expertise and tooling to support their engineers. In this episode Savin Goyal discusses the work that he and his team are doing on the open source machine learning operations platform Metaflow. He shares the inspiration for building an opinionated framework for the full lifecycle of machine learning projects, how it is implemented, and how they have designed it t

Aug 4, 2020 • 44:45

Learning To Program By Building Tiny Python Projects

Summary One of the best methods for learning programming is to just build a project and see how things work first-hand. With that in mind, Ken Youens-Clark wrote a whole book of Tiny Python Projects that you can use to get started on your journey. In this episode he shares his inspiration for the book, his thoughts on the benefits of teaching testing principles and the use of linting and formatting tools, as well as the benefits of trying variations on a working program to see how it behaves. Th

Jul 28, 2020 • 55:00

Idiomatic Functional Programming With DRY Python

Summary Python is an intuitive and flexible language, but that versatility can also lead to problematic designs if you’re not careful. Nikita Sobolev is the CTO of Wemake Services where he works on open source projects that encourage clean coding practices and maintainable architectures. In this episode he discusses his work on the DRY Python set of libraries and how they provide an accessible interface to functional programming patterns while maintaining an idiomatic Python interface. He

Jul 21, 2020 • 47:43

The Past, Present, And Future Of The FLUFL: Barry Warsaw Shares His History With Python

Summary Barry Warsaw has been a member of the Python community since the very beginning. His contributions to the growth of the language and its ecosystem are innumerable and diverse, earning him the title of Friendly Language Uncle For Life. In this episode he reminisces on his experiences as a core developer, a member of the Python Steering Committee, and his roles at Canonical and LinkedIn supporting the use of Python at those companies. In order to know where you are going it is always impor

Jul 13, 2020 • 51:40

Pure Python Configuration Management With PyInfra

Summary Building and managing servers is a challenging task. Configuration management tools provide a framework for handling the various tasks involved, but many of them require learning a specific syntax and toolchain. PyInfra is a configuration management framework that embraces the familiarity of Pure Python, allowing you to build your own integrations easily and package it all up using the same tools that you rely on for your applications. In this episode Nick Barrett explains why he built i

Jul 6, 2020 • 43:09

Build Your Own Domain Specific Language in Python With textX

Summary Programming languages are a powerful tool and can be used to create all manner of applications, however sometimes their syntax is more cumbersome than necessary. For some industries or subject areas there is already an agreed upon set of concepts that can be used to express your logic. For those cases you can create a Domain Specific Language, or DSL to make it easier to write programs that can express the necessary logic with a custom syntax. In this episode Igor Dejanović shares his wo

Jun 30, 2020 • 54:18

Adding Observability To Your Python Applications With OpenTelemetry

Summary Once you release an application into production it can be difficult to understand all of the ways that it is interacting with the systems that it integrates with. The OpenTracing project and its accompanying ecosystem of technologies aims to make observability of your systems more accessible. In this episode Austin Parker and Alex Boten explain how the correlation of tracing and metrics collection improves visibility of how your software is behaving, how you can use the Python SDK to aut

Jun 23, 2020 • 53:44

Build A Personal Knowledge Store With Topic Modeling In Contextualize

Summary Our thought patterns are rarely linear or hierarchical, instead following threads of related topics in unpredictable directions. Topic modeling is an approach to knowledge management which allows for forming a graph of associations to make capturing and organizing your thoughts more natural. In this episode Brett Kromkamp shares his work on the Contextualize project and how you can use it for building your own topic models. He explains why he wrote a new topic modeling engine, how it is

Jun 15, 2020 • 58:06

Open Source Product Analytics With PostHog

Summary You spend a lot of time and energy on building a great application, but do you know how it’s actually being used? Using a product analytics tool lets you gain visibility into what your users find helpful so that you can prioritize feature development and optimize customer experience. In this episode PostHog CTO Tim Glaser shares his experience building an open source product analytics platform to make it easier and more accessible to understand your product. He shares the story of

Jun 8, 2020 • 49:09

Extending The Life Of Python 2 Projects With Tauthon

Summary The divide between Python 2 and 3 lasted a long time, and in recent years all of the new features were added to version 3. To help bridge the gap and extend the viability of version 2 Naftali Harris created Tauthon, a fork of Python 2 that backports features from Python 3. In this episode he explains his motivation for creating it, the process of maintaining it and backporting features, and the ways that it is being used by developers who are unable to make the leap. This was an interest

Jun 2, 2020 • 33:08

Dependency Management Improvements In Pip's Resolver

Summary Dependency management in Python has taken a long and winding path, which has led to the current dominance of Pip. One of the remaining shortcomings is the lack of a robust mechanism for resolving the package and version constraints that are necessary to produce a working system. Thankfully, the Python Software Foundation has funded an effort to upgrade the dependency resolution algorithm and user experience of Pip. In this episode the engineers working on these improvements, Pradyun Geda

May 25, 2020 • 1:16:31

Easy Data Validation For Your Python Projects With Pydantic

Summary One of the most common causes of bugs is incorrect data being passed throughout your program. Pydantic is a library that provides runtime checking and validation of the information that you rely on in your code. In this episode Samuel Colvin explains why he created it, the interesting and useful ways that it can be used, and how to integrate it into your own projects. If you are tired of unhelpful errors due to bad data then listen now and try it out today. Announcements Hello and welco

May 18, 2020 • 47:15

Managing Distributed Teams In The Age Of Remote Work

Summary More of us are working remotely than ever before, many with no prior experience with a remote work environment. In this episode Quinn Slack discusses his thoughts and experience of running Sourcegraph as a fully distributed company. He covers the lessons that he has learned in moving from partially to fully remote, the practices that have worked well in managing a distributed workforce, and the challenges that he has faced in the process. If you are struggling with your remote work situa

May 11, 2020 • 48:45

Maintainable Infrastructure As Code In Pure Python With Pulumi

Summary After you write your application, you need a way to make it available to your users. These days, that usually means deploying it to a cloud provider, whether that’s a virtual server, a serverless platform, or a Kubernetes cluster. To manage the increasingly dynamic and flexible options for running software in production, we have turned to building infrastructure as code. Pulumi is an open source framework that lets you use your favorite language to build scalable and maintainable s

May 4, 2020 • 1:00:55

Teaching Python Machine Learning

Summary Python has become a major player in the machine learning industry, with a variety of widely used frameworks. In addition to the technical resources that make it easy to build powerful models, there is also a sizable library of educational resources to help you get up to speed. Sebastian Raschka’s contribution of the Python Machine Learning book has come to be widely regarded as one of the best references for newcomers to the field. In this episode he shares his experiences as an au

Apr 28, 2020 • 49:25

Build The Next Generation Of Python Web Applications With FastAPI

Summary Python has an embarrasment of riches when it comes to web frameworks, each with their own particular strengths. FastAPI is a new entrant that has been quickly gaining popularity as a performant and easy to use toolchain for building RESTful web services. In this episode Sebastián Ramirez shares the story of the frustrations that led him to create a new framework, how he put in the extra effort to make the developer experience as smooth and painless as possible, and how he embraces extens

Apr 20, 2020 • 58:34

Distributed Computing In Python Made Easy With Ray

Summary Distributed computing is a powerful tool for increasing the speed and performance of your applications, but it is also a complex and difficult undertaking. While performing research for his PhD, Robert Nishihara ran up against this reality. Rather than cobbling together another single purpose system, he built what ultimately became Ray to make scaling Python projects to multiple cores and across machines easy. In this episode he explains how Ray allows you to scale your code easily, how

Apr 14, 2020 • 41:00

Building The Seq Language For Bioinformatics

Summary Bioinformatics is a complex and computationally demanding domain. The intuitive syntax of Python and extensive set of libraries make it a great language for bioinformatics projects, but it is hampered by the need for computational efficiency. Ariya Shajii created the Seq language to bridge the divide between the performance of languages like C and C++ and the ecosystem of Python with built-in support for commonly used genomics algorithms. In this episode he describes his motivation for c

Apr 7, 2020 • 36:25

An Open Source Toolchain For Natural Language Processing From Explosion AI

Summary The state of the art in natural language processing is a constantly moving target. With the rise of deep learning, previously cutting edge techniques have given way to robust language models. Through it all the team at Explosion AI have built a strong presence with the trifecta of SpaCy, Thinc, and Prodigy to support fast and flexible data labeling to feed deep learning models and performant and scalable text processing. In this episode founder and open source author Matthew Honnibal sha

Mar 30, 2020 • 51:20

A Flexible Open Source ERP Framework To Run Your Business

Summary Running a successful business requires some method of organizing the information about all of the processes and activity that take place. Tryton is an open source, modular ERP framework that is built for the flexibility needed to fit your organization, rather than requiring you to model your workflows to match the software. In this episode core developers Nicolas Évrard and Cédric Krier are joined by avid user Jonathan Levy to discuss the history of the project, how it is being used, and

Mar 23, 2020 • 1:07:33

Getting A Handle On Portable C Extensions With hpy

Summary One of the driving factors of Python’s success is the ability for developers to integrate with performant languages such as C and C++. The challenge is that the interface for those extensions is specific to the main implementation of the language. This contributes to difficulties in building alternative runtimes that can support important packages such as NumPy. To address this situation a team of developers are working to create the hpy project, a new interface for extension devel

Mar 16, 2020 • 35:14

Open Source Machine Learning On Quantum Computers With Xanadu AI

Summary Quantum computers promise the ability to execute calculations at speeds several orders of magnitude faster than what we are used to. Machine learning and artificial intelligence algorithms require fast computation to churn through complex data sets. At Xanadu AI they are building libraries to bring these two worlds together. In this episode Josh Izaac shares his work on the Strawberry Fields and Penny Lane projects that provide both high and low level interfaces to quantum hardware for m

Mar 10, 2020 • 57:22

The Advanced Python Task Scheduler

Summary Most long-running programs have a need for executing periodic tasks. APScheduler is a mature and open source library that provides all of the features that you need in a task scheduler. In this episode the author, Alex Grönholm, explains how it works, why he created it, and how you can use it in your own applications. He also digs into his plans for the next major release and the forces that are shaping the improved feature set. Spare yourself the pain of triggering events at just the ri

Mar 2, 2020 • 33:16

Reducing The Friction Of Embedded Software Development With PlatformIO

Summary Embedded software development is a challenging endeavor due to a fragmented ecosystem of tools. Ivan Kravets experienced the pain of programming for different hardware platforms when embroiled in a home automation project. As a result he built the PlatformIO ecosystem to reduce the friction encountered by engineers working with multiple microcontroller architectures. In this episode he describes the complexities associated with targeting multiple platforms, the tools that PlatformIO offe

Feb 25, 2020 • 46:49

APIs, Sustainable Open Source and The Async Web With Tom Christie

Summary Tom Christie is probably best known as the creator of Django REST Framework, but his contributions to the state the web in Python extend well beyond that. In this episode he shares his story of getting involved in web development, his work on various projects to power the asynchronous web in Python, and his efforts to make his open source contributions sustainable. This was an excellent conversation about the state of asynchronous frameworks for Python and the challenges of making a care

Feb 18, 2020 • 43:45

Learning To Program Python By Building Video Games With Arcade

Summary Video games have been a vehicle for learning to program since the early days of computing. Continuing in that tradition, Paul Craven created the Arcade library as a modern alternative to PyGame for use in his classroom. In this episode he explains his motivations for starting a new framework for video game development, his view on the benefits of games in computer education, and how his students and the broader community are using it to build interesting and creative projects. If you are

Feb 11, 2020 • 41:43

Build Your Own Personal Data Repository With Nostalgia

Summary The companies that we entrust our personal data to are using that information to gain extensive insights into our lives and habits while not always making those findings accessible to us. Pascal van Kooten decided that he wanted to have the same capabilities to mine his personal data, so he created the Nostalgia project to integrate his various data sources and query across them. In this episode he shares his motivation for creating the project, how he is using it in his day-to-day, and

Feb 4, 2020 • 32:58

Simplifying Social Login For Your Web Applications

Summary A standard feature in most modern web applications is the ability to log in or register using accounts that you already own on other sites such as Google, Facebook, or Twitter. Building your own integrations for each service can be complex and time consuming, distracting you from the features that you and your users actually care about. Fortunately the Python social auth library makes it easy to support third party authentication with a large and growing number of services with minimal e

Jan 27, 2020 • 34:06

Building A Business On Building Data Driven Businesses

Summary In order for an organization to be data driven they need easy access to their data and a simple way of sharing it. Arik Fraimovich built Redash as a way to address that need by connecting to any data source and building attractive dashboards on top of them. In this episode he shares the origin story of the project, his experiences running a business based on open source, and the challenges of working with data effectively. Announcements Hello and welcome to Podcast.__init__, the podcast

Jan 20, 2020 • 41:27

Using Deliberate Practice To Level Up Your Python

Summary An effective strategy for teaching and learning is to rely on well structured exercises and collaboration for practicing the material. In this episode long time Python trainer Reuven Lerner reflects on the lessons that he has learned in the 5 years since his first appearance on the show, how his teaching has evolved, and the ways that he has incorporated more hands-on experiences into his lessons. This was a great conversation about the benefits of being deliberate in your approach to on

Jan 13, 2020 • 48:40

Checking Up On Python's Role in DevOps

Summary Python has been part of the standard toolkit for systems administrators since it was created. In recent years there has been a shift in how servers are deployed and managed, and how code gets released due to the rise of cloud computing and the accompanying DevOps movement. The increased need for automation and speed of iteration has been a perfect use case for Python, cementing its position as a powerful tool for operations. In this episode Moshe Zadka reflects on his experiences using P

Jan 6, 2020 • 33:36

Python's Built In IDE Isn't Just Sitting IDLE

Summary One of the first challenges that new programmers are faced with is figuring out what editing environment to use. For the past 20 years, Python has had an easy answer to that question in the form of IDLE. In this episode Tal Einat helps us explore its history, the ways it is used, how it was built, and what is in store for its future. Even if you have never used the IDLE editor yourself, it is still an important piece of Python’s strength and history, and this conversation helps to

Dec 23, 2019 • 36:33

Riding The Rising Tides Of Python

Summary The past two decades have seen massive growth in the language, community, and ecosystem of Python. The career of Pete Fein has occurred during that same period and his use of the language has paralleled some of the major shifts in focus that have occurred. In this episode he shares his experiences moving from a trader writing scripts, through the rise of the web, to the current renaissance in data. He also discusses how his engagement with the community has evolved, why he hasn’t n

Dec 16, 2019 • 44:16

Debugging Python Projects With PySnooper

Summary Debugging is a painful but necessary practice in software development. The tools that are available in Python range from the built-in debugger, to tools integrated with your coding environment, to the trusty print function. In this episode Ram Rachum describes his work on PySnooper and how it can be used to speed up your problem solving in complex or legacy applications. Announcements Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great. When

Dec 9, 2019 • 45:31

Making Complex Software Fun And Flexible With Plugin Oriented Programming

Summary Starting a new project is always exciting because the scope is easy to understand and adding new features is fun and easy. As it grows, the rate of change slows down and the amount of communication necessary to introduce new engineers to the code increases along with the complexity. Thomas Hatch, CTO and creator of SaltStack, didn’t want to accept that as an inevitable fact of software, so he created a new paradigm and a proof-of-concept framework to experiment with it. In this epi

Dec 3, 2019 • 1:02:38

Faster And Safer Software Development With Feature Flags

Summary Any software project that is worked on or used by multiple people will inevitably reach a point where certain capabilities need to be turned on or off. In this episode Pete Hodgson shares his experience and insight into when, how, and why to use feature flags in your projects as a way to enable that practice. In addition to the simple on and off controls for certain logic paths, feature toggles also allow for more advanced patterns such as canary releases and A/B testing. This episode ha

Nov 26, 2019 • 1:01:29

From Simple Script To Beautiful Web Application With Streamlit

Summary Building well designed and easy to use web applications requires a significant amount of knowledge and experience across a range of domains. This can act as an impediment to engineers who primarily work in so-called back-end technologies such as machine learning and systems administration. In this episode Adrien Treuille describes how the Streamlit framework empowers anyone who is comfortable writing Python scripts to create beautiful applications to share their work and make it accessib

Nov 18, 2019 • 49:01

Automate Your Server Security With GrapheneX

Summary The internet is rife with bots and bad actors trying to compromise your servers. To counteract these threats it is necessary to diligently harden your systems to improve server security. Unfortunately, the hardening process can be complex or confusing. In this week’s episode 18 year old Orhun Parmaksiz shares the story of how he and his friends created the GrapheneX framework to simplify the process of securing and maintaining your servers using the power and flexibility of Python.

Nov 11, 2019 • 35:42

Accelerating The Adoption Of Python At Wayfair

Summary Large companies often have a variety of programming languages and technologies being used across departments to keep the business running. Python has been gaining ground in these environments because of its flexibility, ease of use, and developer productivity. In order to accelerate the rate of adoption at Wayfair this week’s guest Jonathan Biddle started a team to work with other engineering groups on their projects and show them how best to take advantage of the benefits of Pytho

Nov 3, 2019 • 42:03

Building Quantum Computing Algorithms In Python

Summary Quantum computers are the biggest jump forward in processing power that the industry has seen in decades. As part of this revolution it is necessary to change our approach to algorithm design. D-Wave is one of the companies who are pushing the boundaries in quantum processing and they have created a Python SDK for experimenting with quantum algorithms. In this episode Alexander Condello explains what is involved in designing and implementing these algorithms, how the Ocean SDK helps you

Oct 29, 2019 • 36:15

Illustrating The Landscape And Applications Of Deep Learning

Summary Deep learning is a phrase that is used more often as it continues to transform the standard approach to artificial intelligence and machine learning projects. Despite its ubiquity, it is often difficult to get a firm understanding of how it works and how it can be applied to a particular problem. In this episode Jon Krohn, author of Deep Learning Illustrated, shares the general concepts and useful applications of this technique, as well as sharing some of his practical experience in usin

Oct 22, 2019 • 56:21

Andrew's Adventures In Coderland

Summary Software development is a unique profession in many ways, and it has given rise to its own subculture due to the unique sets of challenges that face developers. Andrew Smith is an author who is working on a book to share his experiences learning to program, and understand the impact that software is having on our world. In this episode he shares his thoughts on programmer culture, his experiences with Python and other language communities, and how learning to code has changed his views o

Oct 14, 2019 • 1:00:27

Network Automation At Enterprise Scale With Python

Summary Designing and maintaining enterprise networks and the associated hardware is a complex and time consuming task. Network automation tools allow network engineers to codify their workflows and make them repeatable. In this episode Antoine Fourmy describes his work on eNMS and how it can be used to automate enterprise grade networks. He explains how his background in telecom networking led him to build an open source platform for network engineers, how it is architected, and how you can use

Oct 8, 2019 • 34:37

Building A Modern Discussion Forum In Python To Support Healthy Communities

Summary Building and sustaining a healthy community requires a substantial amount of effort, especially online. The design and user experience of the digital space can impact the overall interactions of the participants and guide them toward respectful conversation. In this episode Rafał Pitoń shares his experience building the Misago platform for creating community forums. He explains his motivation for creating the project, the lessons he has learned in the process, and how it is being used by

Oct 1, 2019 • 52:22

Exploratory Data Analysis Made Easy At The Command Line

Summary There are countless tools and libraries in Python for data scientists to perform powerful analyses, but they often have a setup cost that acts as a barrier to ad-hoc exploration of data. Visidata is a command line application that eliminates the friction involved with starting the discovery process. In this episode Saul Pwanson explains his motivation for creating it, why a terminal environment is a useful place for this work, and how you can use Visidata for your own work. If you have e

Sep 23, 2019 • 52:51

Cultivating The Python Community In Argentina

Summary The Python community in Argentina is large and active, thanks largely to the motivated individuals who manage and organize it. In this episode Facundo Batista explains how he helped to found the Python user group for Argentina and the work that he does to make it accessible and welcoming. He discusses the challenges of encompassing such a large and distributed group, the types of events, resources, and projects that they build, and his own efforts to make information free and available.

Sep 18, 2019 • 41:46

Python Powered Journalistic Freedom With SecureDrop

Summary The internet has made it easier than ever to share information, but at the same time it has increased our ability to track that information. In order to ensure that news agencies are able to accept truly anonymous material submissions from whistelblowers, the Freedom of the Press foundation has supported the ongoing development and maintenance of the SecureDrop platform. In this episode core developers of the project explain what it is, how it protects the privacy and identity of journal

Sep 10, 2019 • 38:23

Combining Python And SQL To Build A PyData Warehouse

Summary The ecosystem of tools and libraries in Python for data manipulation and analytics is truly impressive, and continues to grow. There are, however, gaps in their utility that can be filled by the capabilities of a data warehouse. In this episode Robert Hodges discusses how the PyData suite of tools can be paired with a data warehouse for an analytics pipeline that is more robust than either can provide on their own. This is a great introduction to what differentiates a data warehouse from

Sep 2, 2019 • 43:44

AI Driven Automated Code Review With DeepCode

Summary Software engineers are frequently faced with problems that have been fixed by other developers in different projects. The challenge is how and when to surface that information in a way that increases their efficiency and avoids wasted effort. DeepCode is an automated code review platform that was built to solve this problem by training a model on a massive array of open sourced code and the history of their bug and security fixes. In this episode their CEO Boris Paskalev explains how the

Aug 26, 2019 • 33:15

Security, UX, and Sustainability For The Python Package Index

Summary PyPI is a core component of the Python ecosystem that most developer’s have interacted with as either a producer or a consumer. But have you ever thought deeply about how it is implemented, who designs those interactions, and how it is secured? In this episode Nicole Harris and William Woodruff discuss their recent work to add new security capabilities and improve the overall accessibility and user experience. It is a worthwhile exercise to consider how much effort goes into making

Aug 19, 2019 • 51:38

Learning To Program In Python With CodeGrades

Summary With the increasing role of software in our world there has been an accompanying focus on teaching people to program. There are numerous approaches that have been attempted to achieve this goal with varying levels of success. Nicholas Tollervey has begun a new effort that blends the approach adopted by musicians and martial artists that uses a series of grades to provide recognition for the achievements of students. In this episode he explains how he has structured the study groups, syll

Aug 12, 2019 • 1:04:02

Build Your Own Knowledge Graph With Zincbase

Summary Computers are excellent at following detailed instructions, but they have no capacity for understanding the information that they work with. Knowledge graphs are a way to approximate that capability by building connections between elements of data that allow us to discover new connections among disparate information sources that were previously uknown. In our day-to-day work we encounter many instances of knowledge graphs, but building them has long been a difficult endeavor. In order to

Aug 5, 2019 • 48:45

Docker Best Practices For Python In Production

Summary Docker is a useful technology for packaging and deploying software to production environments, but it also introduces a different set of complexities that need to be understood. In this episode Itamar Turner-Trauring shares best practices for running Python workloads in production using Docker. He also explains some of the security implications to be aware of and digs into ways that you can optimize your build process to cut down on wasted developer time. If you are using Docker, thinkin

Jul 29, 2019 • 44:01

Protecting The Future Of Python By Hunting Black Swans

Summary The Python language has seen exponential growth in popularity and usage over the past decade. This has been driven by industry trends such as the rise of data science and the continued growth of complex web applications. It is easy to think that there is no threat to the continued health of Python, its ecosystem, and its community, but there are always outside factors that may pose a threat in the long term. In this episode Russell Keith-Magee reprises his keynote from PyCon US in 2019 a

Jul 22, 2019 • 54:35

A Modern Open Source Project Management Platform

Summary Project management is a discipline that has been through many incarnations, spawning an entire industry of businesses and tools. The challenge is to build a platform that is sufficiently powerful and adaptable to fit the workflow of your teams, while remaining opinionated enough to be useful. It also helps to have an open and extensible platform that can be customized as needed. In this episode Pablo Ruiz Múzquiz explains the motivation for creating the open source tool Taiga, how it com

Jul 15, 2019 • 1:09:05

Domain Driven Design For Python

Summary When your software projects start to scale it becomes a greater challenge to understand and maintain all of the pieces. In this episode Henry Percival shares his experiences working with domain driven design in large Python projects. He explains how it is helpful, and how you can start using it for your own applications. This was an informative conversation about software architecture patterns for large organizations and how they can be used by Python developers. Announcements Hello and

Jul 8, 2019 • 55:42

Open Source Automated Machine Learning With MindsDB

Summary Machine learning is growing in popularity and capability, but for a majority of people it is still a black box that we don’t fully understand. The team at MindsDB is working to change this state of affairs by creating an open source tool that is easy to use without a background in data science. By simplifying the training and use of neural networks, and making their logic explainable, they hope to bring AI capabilities to more people and organizations. In this interview George Hosu

Jul 1, 2019 • 58:10

Behind The Scenes At The Python Software Foundation

Summary One of the secrets of the success of Python the language is the tireless efforts of the people who work with and for the Python Software Foundation. They have made it their mission to ensure the continued growth and success of the language and its community. In this episode Ewa Jodlowska, the executive director of the PSF, discusses the history of the foundation, the services and support that they provide to the community and language, and how you can help them succeed in their mission.

Jun 24, 2019 • 37:31

Algorithmic Trading In Python Using Open Tools And Open Data

Summary Algorithmic trading is a field that has grown in recent years due to the availability of cheap computing and platforms that grant access to historical financial data. QuantConnect is a business that has focused on community engagement and open data access to grant opportunities for learning and growth to their users. In this episode CEO Jared Broad and senior engineer Alex Catarino explain how they have built an open source engine for testing and running algorithmic trading strategies in

Jun 17, 2019 • 50:44

Web Application Development Entirely In Python With Anvil

Summary The knowledge and effort required for building a fully functional web application has grown at an accelerated rate over the past several years. This introduces a barrier to entry that excludes large numbers of people who could otherwise be producing valuable and interesting services. To make the onramp easier Meredydd Luff and Ian Davies created Anvil, a platform for full stack web development in pure Python. In this episode Meredydd explains how the Anvil platform is built and how you c

Jun 10, 2019 • 57:31

Building A Business On Serverless Technology

Summary Serverless computing is a recent category of cloud service that provides new options for how we build and deploy applications. In this episode Raghu Murthy, founder of DataCoral, explains how he has built his entire business on these platforms. He explains how he approaches system architecture in a serverless world, the challenges that it introduces for local development and continuous integration, and how the landscape has grown and matured in recent years. If you are wondering how to i

Jun 4, 2019 • 47:13

A Data Catalog For Your PyData Projects

Summary One of the biggest pain points when working with data is getting is dealing with the boilerplate code to load it into a usable format. Intake encapsulates all of that and puts it behind a single API. In this episode Martin Durant explains how to use the Intake data catalogs for encapsulating source information, how it simplifies data science workflows, and how to incorporate it into your projects. It is a lightweight way to enable collaboration between data engineers and data scientists

May 27, 2019 • 50:01

Hardware Hacking Made Easy With CircuitPython

Summary Learning to program can be a frustrating process, because even the simplest code relies on a complex stack of other moving pieces to function. When working with a microcontroller you are in full control of everything so there are fewer concepts that need to be understood in order to build a functioning project. CircuitPython is a platform for beginner developers that provides easy to use abstractions for working with hardware devices. In this episode Scott Shawcroft explains how the proj

May 20, 2019 • 54:06

Building A Privacy Preserving Voice Assistant

Summary Being able to control a computer with your voice has rapidly moved from science fiction to science fact. Unfortunately, the majority of platforms that have been made available to consumers are controlled by large organizations with little incentive to respect users’ privacy. The team at Snips are building a platform that runs entirely off-line and on-device so that your information is always in your control. In this episode Adrien Ball explains how the Snips architecture works, the

May 13, 2019 • 56:28

Hacking The Government With The USDS

Summary The U.S. government has a vast quantity of software projects across the various agencies, and many of them would benefit from a modern approach to development and deployment. The U.S. Digital Services Agency has been tasked with making that happen. In this episode the current director of engineering for the USDS, David Holmes, explains how the agency operates, how they are using Python in their efforts to provide the greatest good to the largest number of people, and why you might want t

May 7, 2019 • 34:04

Probabilistic Modeling In Python (And What That Even Means)

Summary Most programming is deterministic, relying on concrete logic to determine the way that it operates. However, there are problems that require a way to work with uncertainty. PyMC3 is a library designed for building models to predict the likelihood of certain outcomes. In this episode Thomas Wiecki explains the use cases where Bayesian statistics are necessary, how PyMC3 is designed and implemented, and some great examples of how it is being used in real projects. Announcements Hello and

Apr 29, 2019 • 54:49

Exploring Indico: A Full Featured Event Management Platform

Summary Managing an event is rife with inherent complexity that scales as you move from scheduling a meeting to organizing a conference. Indico is a platform built at CERN to handle their efforts to organize events such as the Computing in High Energy Physics (CHEP) conference, and now it has grown to manage booking of meeting rooms. In this episode Adrian Mönnich, core developer on the Indico project, explains how it is architected to facilitate this use case, how it has evolved since its first

Apr 22, 2019 • 53:47

Exploring Python's Internals By Rewriting Them In Rust

Summary The CPython interpreter has been the primary implementation of the Python runtime for over 20 years. In that time other options have been made available for different use cases. The most recent entry to that list is RustPython, written in the memory safe language Rust. One of the added benefits is the option to compile to WebAssembly, offering a browser-native Python runtime. In this episode core maintainers Windel Bouwman and Adam Kelly explain how the project got started, their experie

Apr 15, 2019 • 40:29

Version Control For Your Machine Learning Projects

Summary Version control has become table stakes for any software team, but for machine learning projects there has been no good answer for tracking all of the data that goes into building and training models, and the output of the models themselves. To address that need Dmitry Petrov built the Data Version Control project known as DVC. In this episode he explains how it simplifies communication between data scientists, reduces duplicated effort, and simplifies concerns around reproducing and reb

Apr 8, 2019 • 44:40

Building Scalable Ecommerce Sites On Saleor

Summary Ecommerce is an industry that has largely faded into the background due to its ubiquity in recent years. Despite that, there are new trends emerging and room for innovation, which is what the team at Mirumee focuses on. To support their efforts, they build and maintain the open source Saleor framework for Django as a way to make the core concerns of online sales easy and painless. In this episode Mirek Mencel and Patryk Zawadzki discuss the projects that they work on, the current state o

Apr 1, 2019 • 58:03

A Quick Python Check-in With Naomi Ceder

Summary Naomi Ceder was fortunate enough to learn Python from Guido himself. Since then she has contributed books, code, and mentorship to the community. Currently she serves as the chair of the board to the Python Software Foundation, leads an engineering team, and has recently completed a new draft of the Quick Python Book. In this episode she shares her story, including a discussion of her experience as a technical author and a detailed account of the role that the PSF plays in supporting and

Mar 25, 2019 • 38:32

Wes McKinney's Career In Python For Data Analysis

Summary Python has become one of the dominant languages for data science and data analysis. Wes McKinney has been working for a decade to make tools that are easy and powerful, starting with the creation of Pandas, and eventually leading to his current work on Apache Arrow. In this episode he discusses his motivation for this work, what he sees as the current challenges to be overcome, and his hopes for the future of the industry. Announcements Hello and welcome to Podcast.__init__, the podcast

Mar 18, 2019 • 51:45

The Past, Present, and Future of Deep Learning In PyTorch

Summary The current buzz in data science and big data is around the promise of deep learning, especially when working with unstructured data. One of the most popular frameworks for building deep learning applications is PyTorch, in large part because of their focus on ease of use. In this episode Adam Paszke explains how he started the project, how it compares to other frameworks in the space such as Tensorflow and CNTK, and how it has evolved to support deploying models into production and on m

Mar 10, 2019 • 42:12

How To Include Redis In Your Application Architecture

Summary The Redis database recently celebrated its 10th birthday. In that time it has earned a well-earned reputation for speed, reliability, and ease of use. Python developers are fortunate to have a well-built client in the form of redis-py to leverage it in their projects. In this episode Andy McCurdy and Dr. Christoph Zimmerman explain the ways that Redis can be used in your application architecture, how the Python client is built and maintained, and how to use it in your projects. Announcem

Mar 4, 2019 • 1:01:11

Marshmallow Data Validation Library

Summary Any time that your program needs to interact with other systems it will have to deal with serializing and deserializing data. To prevent duplicate code and provide validation of the data structures that your application is consuming Steven Loria created the Marshmallow library. In this episode he explains how it is built, how to use it for rendering data objects to various serialization formats, and some of the interesting and unique ways that it is incorporated into other projects. Anno

Feb 25, 2019 • 34:04

Unpacking The Python Toolkit For Chaos Engineering

Summary Chaos engineering is the practice of injecting failures into your production systems in a controlled manner to identify weaknesses in your applications. In order to build, run, and report on chaos experiments Sylvain Hellegouarch created the Chaos Toolkit. In this episode he explains his motivation for creating the toolkit, how to use it for improving the resiliency of your systems, and his plans for the future. He also discusses best practices for building, running, and learning from yo

Feb 18, 2019 • 59:40

Computational Musicology For Python Programmers

Summary Music is a part of every culture around the world and throughout history. Musicology is the study of that music from a structural and sociological perspective. Traditionally this research has been done in a manual and painstaking manner, but the advent of the computer age has enabled an increase of many orders of magnitude in the scope and scale of analysis that we can perform. The music21 project is a Python library for computer aided musicology that is written and used by MIT professor

Feb 11, 2019 • 47:49

Classic Computer Science For Pythonistas

Summary Software development is a career that attracts people from all backgrounds, and Python in particular helps to make it an approachable occupation. Because of the variety of paths that can be taken it is becoming increasingly common for practitioners to bypass the traditional computer science education. In this episode David Kopec discusses some of the classic problems that he has found most useful to understand in his work as a professor and practitioner of software engineering. He shares

Feb 4, 2019 • 47:28

What You Need To Know About Open Source Licenses And Intellectual Property

Summary As a developer and user of open source code, you interact with software and digital media every day. What is often overlooked are the rights and responsibilities conveyed by the intellectual property that is implicit in all creative works. Software licenses are a complicated legal domain in their own right, and they can often conflict with each other when you factor in the web of dependencies that your project relies on. In this episode Luis Villa, Co-Founder of Tidelift, explains the ca

Jan 28, 2019 • 1:02:58

Counteracting Code Complexity With Wily

Summary As we build software projects, complexity and technical debt are bound to creep into our code. To counteract these tendencies it is necessary to calculate and track metrics that highlight areas of improvement so that they can be acted on. To aid in identifying areas of your application that are breeding grounds for incidental complexity Anthony Shaw created Wily. In this episode he explains how Wily traverses the history of your repository and computes code complexity metrics over time a

Jan 21, 2019 • 36:18

Teaching Digital Archaeology With Jupyter Notebooks

Summary Computers have found their way into virtually every area of human endeavor, and archaeology is no exception. To aid his students in their exploration of digital archaeology Shawn Graham helped to create an online, digital textbook with accompanying interactive notebooks. In this episode he explains how computational practices are being applied to archaeological research, how the Online Digital Archaeology Textbook was created, and how you can use it to get involved in this fascinating a

Jan 14, 2019 • 49:35

Analyzing Satellite Image Data Using PyTroll

Summary Every day there are satellites collecting sensor readings and imagery of our Earth. To help make sense of that information, developers at the meteorological institutes of Sweden and Denmark worked together to build a collection of Python packages that simplify the work of downloading and processing satellite image data. In this episode one of the core developers of PyTroll explains how the project got started, how that data is being used by the scientific community, and how citizen scie

Jan 7, 2019 • 43:58

Building GraphQL APIs in Python Using Graphene with Syrus Akbary

Summary The web has spawned numerous methods for communicating between applications, including protocols such as SOAP, XML-RPC, and REST. One of the newest entrants is GraphQL which promises a simplified approach to client development and reduced network requests. To make implementing these APIs in Python easier, Syrus Akbary created the Graphene project. In this episode he explains the origin story of Graphene, how GraphQL compares to REST, how you can start using it in your applications, and

Dec 31, 2018 • 52:49

AIORTC: An Asynchronous WebRTC Framework with Jeremy Lainé

Summary Real-time communication over the internet is an amazing feat of modern engineering. The protocol that powers a majority of video calling platforms is WebRTC. In this episode Jeremy Lainé explains why he wrote a Python implementation of this protocol in the form of AIORTC. He also discusses how it works, how you can use it in your own projects, and what he has planned for the future. Preface Hello and welcome to Podcast.__init__, the podcast about Python and the people

Dec 24, 2018 • 40:51

Polyglot: Multi-Lingual Natural Language Processing with Rami Al-Rfou

Summary Using computers to analyze text can produce useful and inspirational insights. However, when working with multiple languages the capabilities of existing models are severely limited. In order to help overcome this limitation Rami Al-Rfou built Polyglot. In this episode he explains his motivation for creating a natural language processing library with support for a vast array of languages, how it works, and how you can start using it for your own projects. He also discusses current resea

Dec 17, 2018 • 43:42

Gnocchi: A Scalable Time Series Database For Your Metrics with Julien Danjou

Summary Do you know what your servers are doing? If you have a metrics system in place then the answer should be “yes”. One critical aspect of that platform is the timeseries database that allows you to store, aggregate, analyze, and query the various signals generated by your software and hardware. As the size and complexity of your systems scale, so does the volume of data that you need to manage which can put a strain on your metrics stack. Julien Danjou built Gnocchi during his

Dec 10, 2018 • 39:16

Keeping Up With The Python Community For Fun And Profit with Dan Bader

Summary Keeping up with the work being done in the Python community can be a full time job, which is why Dan Bader has made it his! In this episode he discusses how he went from working as a software engineer, to offering training, to now managing both the Real Python and PyCoders properties. He also explains his strategies for tracking and curating the content that he produces and discovers, how he thinks about building products, and what he has learned in the process of running his businesses

Dec 3, 2018 • 57:57

Using Calibre To Keep Your Digital Library In Order with Kovid Goyal

Summary Digital books are convenient and useful ways to have easy access to large volumes of information. Unfortunately, keeping track of them all can be difficult as you gain more books from different sources. Keeping your reading device synchronized with the material that you want to read is also challenging. In this episode Kovid Goyal explains how he created the Calibre digital library manager to solve these problems for himself, how it grew to be the most popular application for organizing

Nov 26, 2018 • 43:26

Entity Extraction, Document Processing, And Knowledge Graphs For Investigative Journalists with Friedrich Lindenberg

Summary Investigative reporters have a challenging task of identifying complex networks of people, places, and events gleaned from a mixed collection of sources. Turning those various documents, electronic records, and research into a searchable and actionable collection of facts is an interesting and difficult technical challenge. Friedrich Lindenberg created the Aleph project to address this issue and in this episode he explains how it works, why he built it, and how it is being used. He also

Nov 19, 2018 • 39:12

Bringing Python To The Spanish Language Community with Maricela Sanchez

Summary The Python Community is large and growing, however a majority of articles, books, and presentations are still in English. To increase the accessibility for Spanish language speakers, Maricela Sanchez helped to create the Charlas track at PyCon US, and is an organizer for Python Day Mexico. In this episode she shares her motivations for getting involved in community building, her experiences working on Python Day Mexico and PyCon Charlas, and the lessons that she has learned in the proce

Oct 29, 2018 • 19:29

Of Checklists, Ethics, and Data with Emily Miller and Peter Bull

Summary As data science becomes more widespread and has a bigger impact on the lives of people, it is important that those projects and products are built with a conscious consideration of ethics. Keeping ethical principles in mind throughout the lifecycle of a data project helps to reduce the overall effort of preventing negative outcomes from the use of the final product. Emily Miller and Peter Bull of Driven Data have created Deon to improve the communication and conversation around ethics a

Oct 22, 2018 • 45:16

How Python Is Used To Build A Startup At Wanderu with Chris Kirkos and Matt Warren

Summary The breadth of use cases that Python supports, coupled with the level of productivity that it provides through its ease of use have contributed to the incredible popularity of the language. To explore the ways that it can contribute to the success of a young and growing startup two of the lead engineers at Wanderu discuss their experiences in this episode. Matt Warren, the technical operations lead, explains the ways that he is using Python to build and scale the infrastructure that Wan

Oct 15, 2018 • 34:22

Building A Game In Python At PyWeek with Daniel Pope

Summary Many people learn to program because of their interest in building their own video games. Once the necessary skills have been acquired, it is often the case that the original idea of creating a game is forgotten in favor of solving the problems we confront at work. Game jams are a great way to get inspired and motivated to finally write a game from scratch. This week Daniel Pope discusses the origin and format for PyWeek, his experience as a participant, and the landscape of options for

Oct 9, 2018 • 30:07

Managing Application Secrets with Brian Kelly

Summary Any application that communicates with other systems or services will at some point require a credential or sensitive piece of information to operate properly. The question then becomes how best to securely store, transmit, and use that information. The world of software secrets management is vast and complicated, so in this episode Brian Kelly, engineering manager at Conjur, aims to help you make sense of it. He explains the main factors for protecting sensitive information in your sof

Oct 2, 2018 • 39:04

Django, Channels, And The Asynchronous Web with Andrew Godwin

Summary Once upon a time the web was a simple place with one main protocol and a predictable sequence of request/response interactions with backend applications. This is the era when Django began, but in the intervening years there has been an explosion of complexity with new asynchronous protocols and single page Javascript applications. To help bridge the gap and bring the most popular Python web framework into the modern age Andrew Godwin created Channels. In this episode he explains how the

Sep 24, 2018 • 41:46

The Business Of Technical Authoring With William Vincent

Summary There are many aspects of learning how to program and at least as many ways to go about it. This is multiplicative with the different problem domains and subject areas where software development is applied. In this episode William Vincent discusses his experiences learning how web development mid-career and then writing a series of books to make the learning curve for Django newcomers shallower. This includes his thoughts on the business aspects of technical writing and teaching, the ch

Sep 17, 2018 • 49:38

Keep Your Code Clean Using pre-commit with Anthony Sottile

Summary Maintaining the health and well-being of your software is a never-ending responsibility. Automating away as much of it as possible makes that challenge more achievable. In this episode Anthony Sottile describes his work on the pre-commit framework to simplify the process of writing and distributing functions to make sure that you only commit code that meets your definition of clean. He explains how it supports tools and repositories written in multiple languages, enforces team standards

Sep 10, 2018 • 24:52

Infection Monkey Vulnerability Scanner with Daniel Goldberg

Summary How secure are your servers? The best way to be sure that your systems aren’t being compromised is to do it yourself. In this episode Daniel Goldberg explains how you can use his project Infection Monkey to run a scan of your infrastructure to find and fix the vulnerabilities that can be taken advantage of. He also discusses his reasons for building it in Python, how it compares to other security scanners, and how you can get involved to keep making it better. Preface Hello and

Sep 3, 2018 • 34:24

Fast Stream Processing In Python Using Faust with Ask Solem

Summary The need to process unbounded and continually streaming sources of data has become increasingly common. One of the popular platforms for implementing this is Kafka along with its streams API. Unfortunately, this requires all of your processing or microservice logic to be implemented in Java, so what’s a poor Python developer to do? If that developer is Ask Solem of Celery fame then the answer is, help to re-implement the streams API in Python. In this episode Ask describes how Fau

Aug 27, 2018 • 28:45

Don't Just Stand There, Get Programming! with Ana Bell

Summary Writing a book is hard work, especially when you are trying to teach such a broad concept as programming. In this episode Ana Bell discusses her recent work in writing Get Programming: Learn To Code With Python, including her views on how to separate the principles from the implementation, making the book evergreen in its appeal, and how her experience as a lecturer at MIT has helped her maintain the perspectives of beginners. She also shares her views on the values of learning about pr

Aug 20, 2018 • 35:08

The Masonite Web Framework With Joe Mancuso

Summary Masonite is an ambitious new web framework that draws inspiration from many other successful projects in other languages. In this episode Joe Mancuso, the primary author and maintainer, explains his goal of unseating Django from its position of prominence in the Python community. He also discusses his motivation for building it, how it is architected, and how you can start using it for your own projects. Preface Hello and welcome to Podcast.__init__, the podcast about

Aug 13, 2018 • 43:20

Helping Teacher's Bring Python Into The Classroom With Nicholas Tollervey

Summary There are a number of resources available for teaching beginners to code in Python and many other languages, and numerous endeavors to introduce programming to educational environments. Sometimes those efforts yield success and others can simply lead to frustration on the part of the teacher and the student. In this episode Nicholas Tollervey discusses his work as a teacher and a programmer, his work on the micro:bit project and the PyCon UK education summit, as well as his thoughts on

Aug 6, 2018 • 59:20

Continuous Delivery For Complex Systems Using Zuul with Monty Taylor

Summary Continuous integration systems are important for ensuring that you don’t release broken software. Some projects can benefit from simple, standardized platforms, but as you grow or factor in additional projects the complexity of checking your deployments grows. Zuul is a deployment automation and gating system that was built to power the complexities of OpenStack so it will grow and scale with you. In this episode Monty Taylor explains how he helped start Zuul, how it is designed f

Jul 30, 2018 • 1:07:02

Michael Foord On Testing, Mock, TDD, And The Python Community

Summary Michael Foord has been working on building and testing software in Python for over a decade. One of his most notable and widely used contributions to the community is the Mock library, which has been incorporated into the standard library. In this episode he explains how he got involved in the community, why testing has been such a strong focus throughout his career, the uses and hazards of mocked objects, and how he is transitioning to freelancing full time. Preface Hello and welcom

Jul 23, 2018 • 55:12

The Past, Present, and Future of Twisted with Moshe Zadka

Summary Twisted is one of the earliest frameworks for developing asynchronous applications in Python and it has yet to fulfill its original purpose. It can be used to build network servers that integrate a multitude of protocols, increase the performance of your I/O bound applications, serve as the full web stack for your WSGI projects, and anything else that needs a battle tested and performant foundation. In this episode long time maintainer Moshe Zadka discusses the history of Twisted, how i

Jul 16, 2018 • 34:42

Mike Driscoll And His Career In Python

Summary Mike Driscoll has been writing blogs and books for the Python community for years, including his popular series on the Python Module Of The Week. In his daily work he uses Python to test graphical interfaces written in C++ and QT for embedded platforms. In this episode he explains his work, how he got involved in writing as a regular exercise, and an overview of his recent books. Preface Hello and welcome to Podcast.__init__, the podcast about Python and the people wh

Jul 8, 2018 • 23:32

The Pulp Artifact Repository with Bihan Zhang and Austin Macdonald

Summary Hosting your own artifact repositories can have a huge impact on the reliability of your production systems. It reduces your reliance on the availability of external services during deployments and ensures that you have access to a consistent set of dependencies with known versions. Many repositories only support one type of package, thereby requiring multiple systems to be maintained, but Pulp is a platform that handles multiple content types and is easily extendable to manage everythi

Jul 2, 2018 • 30:44

Bringing Africa Online At Ascoderu with Clemens Wolff

Summary The future is here, it’s just not evenly distributed. One of the places where this is especially true is in sub-Saharan Africa which is a vast region with little to no reliable internet connectivity. To help communities in this region leapfrog infrastructure challenges and gain access to opportunities for education and market information the Ascoderu non-profit has built Lokole. In this episode one of the lead engineers on the project, Clemens Wolff, explains what it is, how it is

Jun 25, 2018 • 42:33

Understanding Machine Learning Through Visualizations with Benjamin Bengfort and Rebecca Bilbro

Summary Machine learning models are often inscrutable and it can be difficult to know whether you are making progress. To improve feedback and speed up iteration cycles Benjamin Bengfort and Rebecca Bilbro built Yellowbrick to easily generate visualizations of model performance. In this episode they explain how to use Yellowbrick in the process of building a machine learning project, how it aids in understanding how different parameters impact the outcome, and the improved understanding among t

Jun 17, 2018 • 55:13

Modern Database Clients On The Command Line with Amjith Ramanujam

Summary The command line is a powerful and resilient interface for getting work done, but the user experience is often lacking. This can be especially pronounced in database clients because of the amount of information being transferred and examined. To help improve the utility of these interfaces Amjith Ramanujam built PGCLI, quickly followed by MyCLI with the Prompt Toolkit library. In this episode he describes his motivation for building these projects, how their popularity led him to create

Jun 11, 2018 • 30:40

Pandas Extension Arrays with Tom Augspurger

Summary Pandas is a swiss army knife for data processing in Python but it has long been difficult to customize. In the latest release there is now an extension interface for adding custom data types with namespaced APIs. This allows for building and combining domain specific use cases and alternative storage mechanisms. In this episode Tom Augspurger describes how the new ExtensionArray works, how it came to be, and how you can start building your own extensions today. Preface Hello and welc

Jun 4, 2018 • 33:26

Making A Difference Through Software With Eric Schles

Summary Software development is a skill that can create value and reduce drudgery in a wide variety of contexts. Sometimes the causes that are most in need of software expertise are also the least able to pay for it. By volunteering our time and abilities to causes that we believe in, we can help make a tangible difference in the world. In this episode Eric Schles describes his experiences working on social justice initiatives and the types of work that proved to be the most helpful to the grou

May 27, 2018 • 43:13

Asking Questions From Data Using Active Learning with Tivadar Danka

Summary One of the challenges of machine learning is obtaining large enough volumes of well labelled data. An approach to mitigate the effort required for labelling data sets is active learning, in which outliers are identified and labelled by domain experts. In this episode Tivadar Danka describes how he built modAL to bring active learning to bioinformatics. He is using it for doing human in the loop training of models to detect cell phenotypes with massive unlabelled datasets. He explains ho

May 21, 2018 • 27:52

Great Expectations For Your Data Pipelines with Abe Gong and James Campbell

Summary Testing is a critical activity in all software projects, but one that is often neglected in data pipelines. The complexities introduced by the inherent statefulness of the problem domain and the interdependencies between systems contribute to make pipeline testing difficult to manage. To make this endeavor more manageable Abe Gong and James Campbell have created Great Expectations. In this episode they discuss how you can use the project to create tests in the exploratory phase of build

May 13, 2018 • 50:43

Exploring Color Theory In Python With Thomas Mansencal

Summary We take it for granted every day, but creating and displaying vivid colors in our digital media is a complicated and often difficult process. There are different ways to represent color, the ways in which they are displayed can cause them to look different, and translating between systems can cause losses of information. To simplify the process of working with color information in code Thomas Mansencal wrote the Colour project. In this episode we discuss his motiviation for creating and

May 6, 2018 • 57:41

Destroy All Software With Gary Bernhardt

Summary Many developers enter the market from backgrounds that don’t involve a computer science degree, which can lead to blind spots of how to approach certain types of problems. Gary Bernhardt produces screen casts and articles that aim to teach these principles with code to make them approachable and easy to understand. In this episode Gary discusses his views on the state of software education, both in academia and bootcamps, the theoretical concepts that he finds most useful in his w

Apr 30, 2018 • 52:07

Scaling Deep Learning Using Polyaxon with Mourad Mourafiq

Summary With libraries such as Tensorflow, PyTorch, scikit-learn, and MXNet being released it is easier than ever to start a deep learning project. Unfortunately, it is still difficult to manage scaling and reproduction of training for these projects. Mourad Mourafiq built Polyaxon on top of Kubernetes to address this shortcoming. In this episode he shares his reasons for starting the project, how it works, and how you can start using it today. Preface Hello and welcome to Podcast.__

Apr 23, 2018 • 36:00

Electricity Map: Real Time Visibility of Power Generation with Olivier Corradi

Summary One of the biggest issues facing us is the availability of sustainable energy sources. As individuals and energy consumers it is often difficult to understand how we can make informed choices about energy use to reduce our impact on the environment. Electricity Map is a project that provides up to date and historical information about the balance of how the energy we are using is being produced. In this episode Olivier Corradi discusses his motivation for creating Electricity Map, how i

Apr 15, 2018 • 47:53

Building And Growing Nylas with Christine Spang

Summary Email is one of the oldest methods of communication that is still in use on the internet today. Despite many attempts at building a replacement and predictions of its demise we are sending more email now than ever. Recognizing that the venerable inbox is still an important repository of information, Christine Spang co-founded Nylas to integrate your mail with the rest of your tools, rather than just replacing it. In this episode Christine discusses how Nylas is built, how it is being us

Apr 8, 2018 • 43:29

Synthetic Data Generation Using Mimesis with Nikita Sobolev

Summary Most applications require data to operate on in order to function, but sometimes that data is hard to come by, so why not just make it up? Mimesis is a library for randomly generating data of different types, such as names, addresses, and credit card numbers, so that you can use it for testing, anonymizing real data, or for placeholders. This week Nikita Sobolev discusses how the project got started, the challenges that it has posed, and how you can use it in your applications. Preface

Apr 1, 2018 • 32:37

Luminoth: AI Powered Computer Vision for Python with Joaquin Alori

Summary Making computers identify and understand what they are looking at in digital images is an ongoing challenge. Recent years have seen notable increases in the accuracy and speed of object detection due to deep learning and new applications of neural networks. In order to make it easier for developers to take advantage of these techniques Tryo Labs built Luminoth. In this interview Joaquín Alori explains how how Luminoth works, how it can be used in your projects, and how it compares to AP

Mar 25, 2018 • 21:27

Thonny: The IDE For Beginning Programmers with Aivar Annamaa

Summary Learning to program is a rewarding pursuit, but is often challenging. One of the roadblocks on the way to proficiency is getting a development environment installed and configured. In order to simplify that process Aivar Annamaa built Thonny, a Python IDE designed for beginning programmers. In this episode he discusses his initial motivations for starting Thonny and how it helps newcomers to Python learn and understand how to write software. Preface Hello and welcome to Podcast._

Mar 18, 2018 • 29:51

Keeping The Beets with Adrian Sampson

Summary Maintaining a consistent taxonomy for your music library is a challenging and time consuming endeavor. Eventually you end up with a mess of folders and files with inconsistent names and missing metadata. Beets is built to solve this problem by programmatically managing the tags and directory structure for all of your music files and providing a fast lookup when you are trying to find that perfect song to play. Adrian Sampson began the project because he was trying to clean up his own mu

Mar 12, 2018 • 39:24

Salabim: Logistics Simulation with Ruud van der Ham

Summary Determining the best way to manage the capacity and flow of goods through a system is a complicated issue and can be exceedingly expensive to get wrong. Rather than experimenting with the physical objects to determine the optimal algorithm for managing the logistics of everything from global shipping lanes to your local bank, it is better to do that analysis in a simulation. Ruud van der Ham has been working in this area for the majority of his professional life at the Dutch port of Rot

Mar 4, 2018 • 51:39

Laboratory: Safer Refactoring with Joe Alcorn

Summary Every piece of software that has been around long enough ends up with some piece of it that needs to be redesigned and refactored. Often the code that needs to be updated is part of the critical path through the system, increasing the risks associated with any change. One way around this problem is to compare the results of the new code against the existing logic to ensure that you aren’t introducing regressions. This week Joe Alcorn shares his work on Laboratory, how the engineer

Feb 26, 2018 • 21:53

Software Architecture For Developers with Neal Ford

Summary Whether it is intentional or accidental, every piece of software has an existing architecture. In this episode Neal Ford discusses the role of a software architect, methods for improving the design of your projects, pitfalls to avoid, and provides some resources for continuing to learn about how to design and build successful systems. Preface Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great. I would like to thank everyon

Feb 18, 2018 • 50:28

ZimboPy

Summary Learning to code is one of the most effective ways to be successful in the modern economy. To that end, Marlene Mhangami and Ronald Maravanyika created the ZimboPy organization to teach women and girls in Zimbabwe how to program in Python. In this episode they are joined by Mike Place to discuss how ZimboPy got started, the projects that their students have worked on, and how the community can get involved. Preface mu- Hello and welcome to Podcast.__init__, the podcast

Feb 11, 2018 • 29:21

PyRay: Pure Python 3D Rendering with Rohit Pandey

Summary Using a rendering library can be a difficult task due to dependency issues and complicated APIs. Rohit Pandey wrote PyRay to address these issues in a pure Python library. In this episode he explains how he uses it to gain a more thorough understanding of mathematical models, how it compares to other options, and how you can use it for creating your own videos and GIFs. Preface Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it

Feb 5, 2018 • 42:41

MonkeyType with Carl Meyer and Matt Page

Summary One of the draws of Python is how dynamic and flexible the language can be. Sometimes, that flexibility can be problematic if the format of variables at various parts of your program is unclear or the descriptions are inaccurate. The growing middle ground is to use type annotations as a way of providing some verification of the format of data as it flows through your application and enforcing gradual typing. To make it simpler to get started with type hinting, Carl Meyer and Matt Page,

Jan 28, 2018 • 48:26

Learn Leap Fly: Using Python To Promote Global Literacy with Kjell Wooding

Summary Learning how to read is one of the most important steps in empowering someone to build a successful future. In developing nations, access to teachers and classrooms is not universally available so the Global Learning XPRIZE serves to incentivize the creation of technology that provides children with the tools necessary to teach themselves literacy. Kjell Wooding helped create Learn Leap Fly in order to participate in the competition and used Python and Kivy to build a platform for child

Jan 21, 2018 • 43:07

Healthchecks.io: Open Source Alerting For Your Cron Jobs with Pēteris Caune

Summary Your backups are running every day, right? Are you sure? What about that daily report job? We all have scripts that need to be run on a periodic basis and it is easy to forget about them, assuming that they are working properly. Sometimes they fail and in order to know when that happens you need a tool that will let you know so that you can find and fix the problem. Pēteris Caune wrote Healthchecks to be that tool and made it available both as an open source project and a hosted version

Jan 14, 2018 • 27:24

Bonobo: Lightweight ETL Toolkit for Python 3 with Romain Dorgueil

Summary A majority of the work that we do as programmers involves data manipulation in some manner. This can range from large scale collection, aggregation, and statistical analysis across distrbuted systems, or it can be as simple as making a graph in a spreadsheet. In the middle of that range is the general task of ETL (Extract, Transform, and Load) which has its own range of scale. In this episode Romain Dorgueil discusses his experiences building ETL systems and the problems that he routine

Jan 7, 2018 • 53:57

Orange: Visual Data Mining Toolkit with Janez Demšar and Blaž Zupan

Summary Data mining and visualization are important skills to have in the modern era, regardless of your job responsibilities. In order to make it easier to learn and use these techniques and technologies Blaž Zupan and Janez Demšar, along with many others, have created Orange. In this episode they explain how they built a visual programming interface for creating data analysis and machine learning workflows to simplify the work of gaining insights from the myriad data sources that are availabl

Dec 31, 2017 • 49:05

Dramatiq: Distributed Task Queue For Python 3 with Bogdan Popa

Summary A majority of projects will eventually need some way of managing periodic or long-running tasks outside of the context of the main application. This is where a distributed task queue becomes useful. For many in the Python community the standard option is Celery, though there are other projects to choose from. This week Bogdan Popa explains why he was dissatisfied with the current landscape of task queues and the features that he decided to focus on while building Dramatiq, a new, opinio

Dec 24, 2017 • 38:13

Jake Vanderplas: Data Science For Academic Research

Summary Jake Vanderplas is an astronomer by training and a prolific contributor to the Python data science ecosystem. His current role is using Python to teach principles of data analysis and data visualization to students and researchers at the University of Washington. In this episode he discusses how he got started with Python, the challenges of teaching best practices for software engineering and reproducible analysis, and how easy to use tools for data visualization can help democratize ac

Dec 17, 2017 • 49:27

Kenneth Reitz

Summary Kenneth Reitz has contributed many things to the Python community, including projects such as Requests, Pipenv, and Maya. He also started the community written Hitchhiker’s Guide to Python, and serves on the board of the Python Software Foundation. This week he talks about his career in the Python community and digs into some of his current work. Preface Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great. I would lik

Dec 10, 2017 • 42:49

Asphalt: A Framework For Asynchronous Network Applications with Alex Grönholm

Summary As we rely more on small, distributed processes for building our applications, being able to take advantage of asynchronous I/O is increasingly important for performance. This week Alex Grönholm explains how the Asphalt Framework was created to make it easier to build these network oriented software stacks and the technical challenges that he faced in the process. Preface Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great.

Dec 3, 2017 • 34:44

Golem: End-To-End Test Automation Framework with Luciano Renzi

Summary The importance of testing your software is widely talked about and well understood. What is not as often discussed is the different types of testing, and how end-to-end tests can benefit your team to ensure proper functioning of your application when it gets released to production. This week Luciano Renzi shares the work that he has done on Golem, a framework for building and executing an automation suite to exercise the entire system from the perspective of the user. He discusses his r

Nov 25, 2017 • 54:04

Graphite Metrics Stack with Jason Dixon and Dan Cech

Summary Do you know what is happening in your production systems right now? If you have a comprehensive metrics platform then the answer is yes. If your answer is no, then this episode is for you. Jason Dixon and Dan Cech, core maintainers of the Graphite project, talk about how graphite is architected to capture your time series data and give you the ability to use it for answering questions. They cover the challenges that have been faced in evolving the project, the strengths that have let it

Nov 19, 2017 • 1:14:18

Surprise! Recommendation Algorithms with Nicolas Hug

Summary A relevant and timely recommendation can be a pleasant surprise that will delight your users. Unfortunately it can be difficult to build a system that will produce useful suggestions, which is why this week’s guest, Nicolas Hug, built a library to help with developing and testing collaborative recommendation algorithms. He explains how he took the code he wrote for his PhD thesis and cleaned it up to release as an open source library and his plans for future development on it. Pr

Nov 11, 2017 • 30:22

Rasa: Build Your Own AI Chatbot with Joey Faulkner

Summary With the proliferation of messaging applications, there has been a growing demand for bots that can understand our wishes and perform our bidding. The rise of artificial intelligence has brought the capacity for understanding human language. Combining these two trends gives us chatbots that can be used as a new interface to the software and services that we depend on. This week Joey Faulkner shares his work with Rasa Technologies and their open sourced libraries for understanding natura

Nov 4, 2017 • 49:00

Eliot: Effective Logging with Itamar Turner-Trauring

Summary Understanding what is happening in a software system can be difficult, especially when you have inconsistent log messages. Itamar Turner-Trauring created Eliot to make it possible for your project to tell you a story about how transactions flow through your program. In this week’s episode we go deep on proper logging practices, anti patterns, and how to improve your ability to debug your software with log messages. Preface Hello and welcome to Podcast.__init__,

Oct 29, 2017 • 49:48

Donkey: Building Self Driving Cars with Will Roscoe

Summary Do you wish that you had a self-driving car of your own? With Donkey you can make that dream a reality. This week Will Roscoe shares the story of how he got involved in the arena of self-driving car hobbyists and ended up building a Python library to act as his pilot. We talked about the hardware involved, how he has evolved the code to meet unexpected challenges, and how he plans to improve it in the future. So go build your own self driving car and take it for a spin! Preface Hello

Oct 22, 2017 • 33:49

Event Sourcing with John Bywater

Summary The way that your application handles data and the way that it is represented in your database don’t always match, leading to a lot of brittle abstractions to reconcile the two. In order to reduce that friction, instead of overwriting the state of your application on every change you can log all of the events that take place and then render the current state from that sequence of events. John Bywater joins me this week to discuss his work on the Event Sourcing library, why you mig

Oct 15, 2017 • 1:08:26

Kalliope with Nicolas Marcq and Thibaud Buffet

Summary Wouldn’t it be nice to have a personal assistant to answer your questions, help you remember important tasks, and control your environment? Meet Kalliope, a Python powered, modular, voice controlled automation platform. This week Nicolas Marcq and Thibaud Buffet explain how they started the project, what makes it stand out from other open source and commercial options, and how you can start using it today. Preface Hello and welcome to Podcast.__init__, the podca

Oct 8, 2017 • 32:33

Modoboa with Antoine Nguyen

Summary Email has long been the most commonly used means of communication on the internet. This week Antoine Nguyen talks about his work on the Modoboa project to make hosting your own mail server easier to manage. He discusses how the project got started, the tools that it ties together, and how he used Django to build a webmail and admin interface to make it more approachable. Preface Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it

Oct 1, 2017 • 33:18

QuTiP with Paul Nation

Summary The future of computation and our understanding of the world around us is driven by the quantum world. This week Paul Nation explains how the Quantum Toolbox in Python (QuTiP) is being used in research projects that are expanding our knowledge of the physical universe. Preface Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great. I would like to thank everyone who supports us on Patreon. Your contributions help to make the s

Sep 24, 2017 • 36:31

Lego Robotics with David Lechner and Denis Demidov

Summary Do you like Legos, robots, and Python? This week I am joined by David Lechner and Denis Demidov to talk about the ev3dev project and how you can program your Lego Mindstorms with Python! Preface Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great. I would like to thank everyone who supports us on Patreon. Your contributions help to make the show sustainable. When you’re ready to launch your next project you’ll n

Sep 17, 2017 • 44:01

Cloud-Init with Scott Moser

Summary Server administration is a complex endeavor, but there are some tools that can make life easier. If you are running your workload in a cloud environment then cloud-init is here to help. This week Scott Moser explains what cloud-init is, how it works, and how it became the de-facto tool for configuring your Linux servers at boot. Preface Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great. I would like to thank everyone who

Sep 10, 2017 • 49:50

Biopython with Peter Cock, Wibowo Arindrarto, and Tiago Antão

Summary Advances in the techniques used for genome sequencing are providing us with more information to unlock the secrets of biology. But how does that data get processed and analyzed? With Python of course! This week I am joined by some of the core maintainers of Biopython to discuss what bioinformatics is, how Python is used to help power the research in the field, and how Biopython helps to tie everything together. Preface Hello and welcome to Podcast.__init__, the podcas

Sep 3, 2017 • 45:29

opsdroid with Jacob Tomlinson

Summary Server administration is an activity that often happens in an isolated context in a terminal. ChatOps is a way of bringing that work into a shared environment and unlocking more collaboration. This week Jacob Tomlinson talks about the work he has done on opsdroid, a new bot framework targeted at tying together the various services and environments that modern production systems rely on. Preface Hello and welcome to Podcast.__init__, the podcast about Python and the pe

Aug 26, 2017 • 45:41

Ergonomica with Liam Schumm

Summary As developers we spend a lot of our work day in a terminal window, using shells that were designed 30 years ago. This week Liam Schumm joins me to explain why he decided to write a new, more ergonomic shell environment to simplify his workflow. Preface Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great. I would like to thank everyone who supports us on Patreon. Your contributions help to make the show sustainable. When you

Aug 20, 2017 • 42:04

Data Retriever with Henry Senyondo

Summary Analyzing and interpreting data is a large portion of the work involved in scientific research. Getting to that point can be a lot of work on its own because of all of the steps required to download, clean, and organize the data prior to analysis. This week Henry Senyondo talks about the work he is doing with Data Retriever to make data preparation as easy as retriever install. Preface Hello and welcome to Podcast.__init__, the podcast about Python and the people who

Aug 12, 2017 • 17:55

Coverage.py with Ned Batchelder

Summary We write tests to make sure that our code is correct, but how do you make sure the tests are correct? This week Ned Batchelder explains how coverage.py fills that need, how he became the maintainer, and how it works under the hood. Preface Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great. I would like to thank everyone who supports us on Patreon. Your contributions help to make the show sustainable. When you’re rea

Aug 6, 2017 • 51:54

Yosai with Darin Gordon

Summary For any program that is used by more than one person you need a way to control identity and permissions. There are myriad solutions to that problem, but most of them are tied to a specific framework. Yosai is a flexible, general purpose framework for managing role-based access to your applications that has been decoupled from the underlying platform. This week the author of Yosai, Darin Gordon, joins us to talk about why he started it, his experience porting it from Java, and where he h

Jul 30, 2017 • 42:00

Moving to MongoDB with Michael Kennedy

Summary There are dozens of decisions that need to be made when building an application. Sometimes this can lead to analysis paralysis and prevent you from making progress, so don’t let the perfect be the enemy of the good. This week Michael Kennedy shares his experience with evolving his application architecture when his business needs outgrew his initial designs. Preface Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great.

Jul 22, 2017 • 47:58

Zulip Chat with Tim Abbott

Summary In modern work environments the email is being edged out by group chat as the preferred method of communication. The majority of the platforms used are commercial and closed source, but there is one project that is working to change that. Zulip is a project that aims to redefine how effective teams communicate and it is already gaining ground. This week Tim Abbott shares the story of how Zulip got started, how it is built, and why you might want to start using it. Preface Hello and w

Jul 16, 2017 • 1:00:40

NAPALM with David Barroso and Mircea Ulinic

Summary Routers and switches are the stitches in the invisible fabric of the internet which we all rely on. Managing that hardware has traditionally been a very manual process, but the NAPALM (Network Automation and Programmability Abstraction Layer with Multivendor support) is helping to change that. This week David Barroso and Mircea Ulinic explain how Python is being used to make sure that you can watch those cat videos. Preface Hello and welcome to Podcast.__init__, the p

Jul 9, 2017 • 58:10

Automat State Machines with Glyph Lefkowitz

Summary The venerable ‘if’ statement is a cornerstone of program flow and busines logic, but sometimes it can grow unwieldy and lead to unmaintainable software. One alternative that can result in cleaner and easier to understand code is a state machine. This week Glyph explains how Automat was created and how it has been used to upgrade portions of the Twisted project. Preface Hello and welcome to Podcast.__init__, the podcast about Python and the people who make

Jul 2, 2017 • 49:28

Nuclear Engineering with Dr. Katy Huff

Summary Access to affordable and consistent electricity is one of the big challenges facing our modern society. Nuclear energy is one answer because of its reliable output and carbon-free operation. To make this energy accessible to a larger portion of the global population further reasearch and innovation in reactor design and fuel sources is necessary, and that is where Python can help. This week Dr. Katy Huff talks about the research that she is doing, the problems facing the nuclear industr

Jun 24, 2017 • 38:16

Industrial Automation with Jonas Neubert

Summary We all use items that are produced in factories, but do you ever stop to think about the code that powers that production? This week Jonas Neubert takes us behind the scenes and talks about the systems and software that power modern facilities, the development workflows, and how Python gets used to tie everything together. Preface Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great. I would like to thank everyone who suppor

Jun 18, 2017 • 1:02:07

Jedi Code Completion with David Halter

Summary When you’re writing python code and your editor offers some suggestions, where does that suggestion come from? The most likely answer is Jedi! This week David Halter explains the history of how the Jedi auto completion library was created, how it works under the hood, and where he plans on taking it. Preface Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great. I would like to thank everyone who supports us on Patreon.

Jun 11, 2017 • 42:56

Coconut with Evan Hubinger

Summary Functional programming is gaining in popularity as we move to an increasingly parallel world. Sometimes you want access to purely functional syntax and capabilities but you don’t want to have to learn an entirely new language. Coconut is here to help! This week Evan Hubinger explains how Coconut is a functional language that compiles to Python and can be mixed and matched with the rest of your program. Preface Hello and welcome to Podcast.__init__, the podcast a

Jun 4, 2017 • 33:31

Cauldron with Scott Ernst

Summary The notebook format that has been exemplified by the IPython/Jupyter project has gained in popularity among data scientists. While the existing formats have proven their value, they are still susceptible with difficulties in collaboration and maintainability. Scott Ernst created the Cauldron notebook to be testable, production ready, and friendly to version control. This week we explore the capabilities, use cases, and architecture of Cauldron and how you can start using it today! Pref

May 28, 2017 • 37:52

Tech Debt and Refactoring at Yelp! with Andrew Mason

Summary Healthy code makes for happy coders, and there are many ways to measure the health of a project. This week Andrew Mason talks about the Undebt project from Yelp!, as well as some of the other tools and practices that have been developed to make sure that the balance on their technical debt card stays low. Give it a listen to learn how and why to measure and address the painful parts of your software. Preface Hello and welcome to Podcast.__init__, the podcast about Pyt

May 20, 2017 • 34:27

LBRY with Jeremy Kauffman

Summary Content discovery and delivery and how it works in the digital realm is one of the most critical pieces of our modern economy. The blockchain is one of the most disruptive and transformative technologies to arrive in recent years. This week Jeremy Kauffman explains how the company and platform of LBRY are combining the two in an attempt to redefine how content creators and consumers interact by creating a new distributed marketplace for all kinds of media. Preface Hello and welcome t

May 14, 2017 • 39:40

Python Goes To The Movies with Dhruv Govil

Summary Movies are magic, and Python is part of what makes that magic possible. We go behind the curtain this week with Dhruv Govil to learn about how Python gets used to bring a movie from concept to completion. He shares the story of how he got started in film, the tools that he uses day to day, and some resources for further learning. Preface Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great. I would like to thank everyone who

May 6, 2017 • 41:42

Scapy with Guillaume Valadon

Summary Network protocols are often inscrutable, but if you have an effective way to experiment with them then they expose a lot of power. This week Guillaume Valadon explains how Scapy can be used to inspect your network traffic, test the security of your systems, and develop brand new protocols, all in Python! Preface Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great. I would like to thank everyone who supports us on Patreon. Y

Apr 29, 2017 • 31:59

yt-project with Nathan Goldbaum and John Zuhone

Summary Astrophysics and cosmology are fields that require working with complex multidimensional data to simulate the workings of our universe. The yt project was created to make working with this data and providing useful visualizations easy and fun. This week Nathan Goldbaum and John Zuhone share the story of how yt got started, how it works, and how it is being used right now. Announcements The Open Data Science Conference is coming to Boston May 3rd-5th. Get your ticket now so you don&#8

Apr 22, 2017 • 38:09

Scikit-Image with Stefan van der Walt and Juan Nunez-Iglesias

Summary Computer vision is a complex field that spans industries with varying needs and implementations. Scikit-Image is a library that provides tools and techniques for people working in the sciences to process the visual data that is critical to their research. This week Stefan Van der Walt and Juan Nunez-Iglesias, co-authors of Elegant SciPy, talk about how the project got started, how it works, and how they are using it to power their experiments. Preface Hello and welcome to Podcast.&#9

Apr 16, 2017 • 41:53

Oscar Ecommerce with David Winterbottom and Michael van Tellingen

Summary If you have a product to sell, whether it is a physical good or a subscription service, then you need a way to manage your transactions. The Oscar ecommerce framework for Django is a flexible, extensible, and well built way for you to add that functionality to your website. This week David Winterbottom and Michael van Tellingen talk about how the project got started, how it works under the covers, and how you can start using it today. Preface Hello and welcome to Podcast.__in

Apr 8, 2017 • 53:38

Duplicity with Kenneth Loafman

Summary Everyone who uses a computer on a regular basis knows the importance of backups. Duplicity is one of the most widely used backup technologies, and it’s written in Python! This week Kenneth Loafman shares how Duplicity got started, how it works, and why you should be using it every day. Preface Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great. I would like to thank everyone who has donated to the show. Your contribu

Apr 1, 2017 • 35:17

Digital Identity, Privacy, and Security with Brian Warner

Summary As the internet and digital technologies continue to infiltrate our way of life, we are forced to consider how our concepts of identity and security are reflected in these spaces. Brian Warner joins me this week to discuss his work on privacy focused projects that he has worked on, including the Tahoe LAFS, Firefox Sync, and Magic Wormhole. He also has some intriguing ideas about how we can replace passwords and what it means to have an online identity. Preface Hello and welcome to P

Mar 25, 2017 • 46:43

Crossbar.io with Tobias Oberstein and Alexander Gödde

Summary As our system architectures and the Internet of Things continue to push us towards distributed logic we need a way to route the traffic between those various components. Crossbar.io is the original implementation of the Web Application Messaging Protocol (WAMP) which combines Remote Procedure Calls (RPC) with Publish/Subscribe (PubSub) communication patterns into a single communication layer. In this episode Tobias Oberstein describes the use cases and design patterns that become possib

Mar 18, 2017 • 52:47

MetPy: Taming The Weather With Python

Summary What’s the weather tomorrow? That’s the question that meteorologists are always trying to get better at answering. This week the developers of MetPy discuss how their project is used in that quest and the challenges that are inherent in atmospheric and weather research. It is a fascinating look at dealing with uncertainty and using messy, multidimensional data to model a massively complex system. Preface Hello and welcome to Podcast.__init__, the podcast a

Mar 11, 2017 • 52:23

The Update Framework: Securing Your Software Updates with Justin Cappos

Summary If you write software then there’s a good probability that you have had to deal with installing dependencies, but did you stop to ask whether you’re installing what you think you are? My guest this week is Professor Justin Cappos from the Secure Systems Lab at New York University and he joined me to discuss his work on The Update Framework which was built to guarantee that you never install a compromised package in your systems. Preface Hello and welcome to Podcast._&

Mar 4, 2017 • 37:21

Pandas with Jeff Reback

Summary Pandas is one of the most versatile and widely used tools for data manipulation and analysis in the Python ecosystem. This week Jeff Reback explains why that is, how you can use it to make your life easier, and what you can look forward to in the months to come. Preface Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great. I would like to thank everyone who has donated to the show. Your contributions help us make the show su

Feb 26, 2017 • 49:23

PyTables with Francesc Alted

Summary HDF5 is a file format that supports fast and space efficient analysis of large datasets. PyTables is a project that wraps and expands on the capabilities of HDF5 to make it easy to integrate with the larger Python data ecosystem. Francesc Alted explains how the project got started, how it works, and how it can be used for creating sharable and archivable data sets. Preface Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great

Feb 18, 2017 • 49:16

SKIDL with Dave Vandenbout

Summary As circuits and electronic components become more complex, visual circuit building tools are more difficult to use effectively. If you wish that you could just write your circuits in Python then you’re in luck! Dave Vandenbout created a library called SKIDL that brings the power and flexibility of Python to the realm of Electrical Engineering and he tells us all about it in this weeks show. Preamble Hello and welcome to Podcast.__init__, the podcast about Python

Feb 11, 2017 • 40:50

Parsing and Parsers with Dave Beazley and Erik Rose

Summary If you have ever found yourself frustrated by a complicated regular expression or wondered how you can build your own dialect of Python then you need a parser. Dave Beazley and Erik Rose talk about what parsers are, how some of them work, and what you can do with them in this episode. Preface Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great. I would like to thank everyone who has donated to the show. Your contributions h

Feb 4, 2017 • 50:01

Home Assistant with Paulus Schoutsen

Summary Don’t you wish you could make all of your devices talk to each other? Check out Home Assistant, the Python 3 platform for unified automation. Paulus Schoutsen shares the story of how the project got started, what makes it tick, and how you can use it today! Introduction Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great. I would like to thank everyone who has donated to the show. Your contributions help us make the s

Jan 28, 2017 • 41:47

Cryptography with Paul Kehrer

Summary Sooner or later you will need to encrypt or hash some data. Thankfully we have the Cryptography library, along with the other projects maintained by the Python Cryptographic Authority, to make sure that your crypto is done right. In this episode Paul Kehrer talks about how the PyCA got started, the projects that they maintain, and how you can start using cryptography in your programs today. Brief Introduction Hello and welcome to Podcast.__init__, the podcast about Py

Jan 21, 2017 • 42:00

Translate House with Dwayne Bailey and Ryan Northey

Summary What is internationalization, when should you add it to your program, and how do you get started? This week Dwayne Bailey and Ryan Northey tell us about their work with Translate House and the different projects that they have built to make translating your software easier. Brief Introduction Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great. I would like to thank everyone who has donated to the show. Your contributions h

Jan 14, 2017 • 58:53

Morepath with Martijn Faassen

Summary Python has a wide and growing variety of web frameworks to choose from, but if you want one with super powers then you need Morepath. This week Martijn Faassen shares the story of how Morepath was created, how it differentiates itself from the other available options, and how you can use it to power your next project. Brief Introduction Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great. I would like to thank everyone who

Jan 7, 2017 • 1:05:51

ERPNext with Rushabh Mehta

Summary If you need to track all of the pieces of a business and don’t want to use 15 different tools then you should probably be looking at an ERP (Enterprise Resource Planning) system. Unfortunately, a lot of them are big, clunky, and difficult to manage, so Rushabh Mehta decided to build one that isn’t. ERPNext is an open-source, web-based, easy to use ERP platform built with Python. Brief Introduction Hello and welcome to Podcast.__init__, the podcast about Py

Dec 31, 2016 • 30:34

Jackie Kazil

Summary Jackie Kazil has led a distinguished and varied career with a strong focus on providing information and tools that empower others. This includes her work in data journalism, as a presidential innovation fellow, co-founding 18F, co-authoring a book, and being elected to the board of the Python Software Foundation. In this episode she shares these stories and more with us and how Python has helped her along the way. Brief Introduction Hello and welcome to Podcast.__init__, the podcast

Dec 24, 2016 • 39:48

Weblate with Michal Čihař

Summary Adding translations to our projects makes them usable in more places by more people which, ultimately, makes them more valuable. Managing the localization process can be difficult if you don’t have the right tools, so this week Michal čihař tells us about the Weblate project and how it simplifies the process of integrating your translations with your source code. Brief Introduction Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great.

Dec 17, 2016 • 32:34

SpaCy with Matthew Honnibal

Summary As the amount of text available on the internet and in businesses continues to increase, the need for fast and accurate language analysis becomes more prominent. This week Matthew Honnibal, the creator of SpaCy, talks about his experiences researching natural language processing and creating a library to make his findings accessible to industry. Brief Introduction Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great. I would like to thank

Dec 11, 2016 • 36:48

Kinto with Alexis Metaireau and Mathieu Leplatre

Summary Are you looking for a backend as a service offering where you have full control of your data? Look no further than Kinto! This week Alexis Metaireau and Mathieu Leplatre share the story of how Kinto was created, how it works under the covers, and some of the ways that it is being used at Mozilla and around the web. Brief Introduction Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great. I would like to thank everyone who has donated to the

Dec 4, 2016 • 56:02

Plone with Eric Steele

Summary Plone is one of the first CMS projects to be built using Python and it is still being actively developed. This week Eric Steele, the release manager for Plone, tells us about how it got started, how it is architected, and how the community is one of its greatest strengths Brief Introduction Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great. I would like to thank everyone who has donated to the show. Your contributions help us make the sh

Nov 26, 2016 • 50:27

Retrospective

Summary In this episode Chris and I look back at the past 83 episodes of the show and talk about what we learned, what we’ve enjoyed, and some of the highlights. Brief Introduction Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great. I would like to thank everyone who has donated to the show. Your contributions help us make the show sustainable. When you’re ready to launch your next project you’ll need somewhere to deploy it. Che

Nov 19, 2016 • 37:30

HouseCanary with Travis Jungroth

Summary Housing is something that we all have experience with, but many don’t understand the complexities of the market. This week Travis Jungroth talks about how HouseCanary uses data to make the business of real estate more transparent. Brief Introduction Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great. I would like to thank everyone who has donated to the show. Your contributions help us make the show sustainable. When you’re re

Nov 12, 2016 • 39:45

Mycroft with Steve Penrod

Summary Speech is the most natural interface for communication, and yet we force ourselves to conform to the limitations of our tools in our daily tasks. As computation becomes cheaper and more ubiquitous and artificial intelligence becomes more capable, voice becomes a more practical means of controlling our environments. This week Steve Penrod shares the work that is being done on the Mycroft project and the company of the same name. He explains how he met the other members of the team, how t

Nov 5, 2016 • 1:05:13

Annapoornima Koppad

Summary Annapoornima Koppad is a director of the PSF, founder of the Bangalore chapter of PyLadies, and is a Python instructor at the Indian Institute of Science. In this week’s episode she talks about how she got started with Python, her experience running the PyLadies meetup, and working with the PSF. Brief Introduction Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great. I would like to thank everyone who has donated to the show. Your con

Oct 29, 2016 • 19:23

Python for GIS with Sean Gillies

Summary Location is an increasingly relevant aspect of software systems as we have more internet connected devices with GPS capabilities. GIS (Geographic Information Systems) are used for processing and analyzing this data, and fortunately Python has a suite of libraries to facilitate these endeavors. This week Sean Gillies, an author and contributor of many of these tools, shares the story of his career and contributions, and the work that he is doing at MapBox. Brief Introduction Hello and

Oct 22, 2016 • 37:50

K Lars Lohn

Summary K Lars Lohn has had a long and varied career, spending his most recent years at Mozilla. This week he shares some of his stories about getting involved with Python, his work with Mozilla, and his inspiration for the closing keynote at PyCon US 2016. He also elaborates on the intricate mazes that he draws and his life as an organic farmer in Oregon. Brief Introduction Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great. I would like to than

Oct 15, 2016 • 42:22

Lorena Mesa

Summary One of the great strengths of the Python community is the diversity of backgrounds that our practitioners come from. This week Lorena Mesa talks about how her focus on political science and civic engagement led her to a career in software engineering and data analysis. In addition to her professional career she founded the Chicago chapter of PyLadies, helps teach women and kids how to program, and was voted onto the board of the PSF. Brief Introduction Hello and welcome to Podcast.__

Oct 8, 2016 • 42:23

Podbuzzz with Kyle Martin

Summary Podcasts are becoming more popular now than they ever have been. Podbuzzz is a service for helping podcasters to track their reviews and imporove SEO to reach a wider audience. In this episode we spoke with Kyle Martin about his experience using Python to build Podbuzzz and manage it in production. Brief Introduction Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great. I would like to thank everyone who has donated to the show. Your contri

Oct 1, 2016 • 38:36

PsychoPy with Jonathan Peirce

Summary We’re delving into the complex workings of your mind this week on Podcast.init with Jonathan Peirce. He tells us about how he started the PsychoPy project and how it has grown in utility and popularity over the years. We discussed the ways that it has been put to use in myriad psychological experiments, the inner workings of how to design and execute those experiments, and what is in store for its future. Brief Introduction Hello and welcome to Podcast.__init__, the podcast about Pyt

Sep 25, 2016 • 1:12:10

Sandstorm.io with Asheesh Laroia

Summary Sandstorm.io is an innovative platform that aims to make self-hosting applications easier and more maintainable for the average individual. This week we spoke with Asheesh Laroia about why running your own services is desirable, how they have made security a first priority, how Sandstorm is architected, and what the installation process looks like. Brief Introduction Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it great. I would like to than

Sep 17, 2016 • 59:35

Python at Zalando

Summary Open source has proven its value in many ways over the years. In many companies that value is purely in terms of consuming available projects and platforms. In this episode Zalando describes their recent move to creating and releasing a number of their internal projects as open source and how that has benefited their business. We also discussed how they are leveraging Python and a couple of the libraries that they have published. Brief Introduction Hello and welcome to Podcast.__init

Sep 10, 2016 • 40:27

Alex Martelli

Summary Alex Martelli has dedicated a large part of his career to teaching others how to work with software. He has the highest number of Python questions answered on Stack Overflow, he has written and co-written a number of books on Python, and presented innumerable times at conferences in multiple countries. We spoke to him about how he got started in software, his work with Google, and the trends in development and design patterns that are shaping modern software engineering. Brief Introduc

Sep 3, 2016 • 1:04:49

Dave Beazley

Summary Dave Beazley has been using and teaching Python since the early days of the language. He has also been instrumental in spreading the gospel of asynchronous programming and the many ways that it can improve the performance of your programs. This week I had the pleasure of speaking with him about his history with the language and some of his favorite presentations and projects. Brief Introduction Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it

Aug 27, 2016 • 45:42

GenSim with Radim Řehůřek

Summary Being able to understand the context of a piece of text is generally thought to be the domain of human intelligence. However, topic modeling and semantic analysis can be used to allow a computer to determine whether different messages and articles are about the same thing. This week we spoke with Radim Řehůřek about his work on GenSim, which is a Python library for performing unsupervised analysis of unstructured text and applying machine learning models to the problem of natural langua

Aug 20, 2016 • 53:28

Python on Windows with Steve Dower

Summary In order for Python to continue to attract new users, we need to have an easy way for people to get started with it, and Windows is still the most widely used operating system among computers. Steve Dower is the build maintainer for the Windows installers of Python and this week we spoke with him about his work in that role. He told us about the changes that he has made to the installer to make it easier for new users to get started and how modern updates to the packaging ecosystem for

Aug 13, 2016 • 54:24

PyCon Canada with Francis Deslauriers and Peter McCormick

Summary Aside from the national Python conferences such as PyCon US and EuroPyCon there are a number of regional conferences that operate at a smaller scale to service their local communities. This week we interviewed Peter McCormick and Francis Deslauriers about their work organizing PyCon Canada to provide a venue for Canadians to talk about how they are using the language. If you happen to be near Toronto in November then you should get a ticket and help contribute to their success! Brief I

Aug 6, 2016 • 46:01

Test Engineering with Cris Medina

Summary We all know that testing is an important part of software and systems development. The problem is that as our systems and applications grow, the amount of testing necessary increases at an exponential rate. Cris Medina joins us this week to talk about some of the problems and approaches associated with testing these complex systems and some of the ways that Python can help. Brief Introduction Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it g

Jul 30, 2016 • 58:10

Crossing The Streams - Talk Python with Michael Kennedy

Summary The same week that we released our first episode of Podcast.__init__, Michael Kennedy was publishing the very first episode of Talk Python To Me. The years long drought of podcasts about Python has been quenched with a veritable flood of quality content as we have both continued to deliver the stories of the wonderful people who make our community such a wonderful place. This week we interviewed Michael about what inspired him to get started, his process and experience as Talk Python co

Jul 23, 2016 • 1:17:48

Zorg with Gunther Cox and Kevin Brown

Summary Everyone loves to imagine what they would do if they had their own robot. This week we spoke with Gunther Cox and Kevin Brown about their work on Zorg, which is a Python library for building a robot of your own! We discussed how the project got started, what platforms it supports, and some of the projects that have been built with it. Give it a listen and then get building! Brief Introduction Hello and welcome to Podcast.__init__, the podcast about Python and the people who make it g

Jul 17, 2016 • 25:19

Mypy with David Fisher and Greg Price

Summary As Python developers we are fond of the dynamic nature of the language. Sometimes, though, it can get a bit too dynamic and that’s where having some type information would come in handy. Mypy is a project that aims to add that missing level of detail to function and variable definitions so that you don’t have to go hunting 5 levels deep in the stack to understand what shape that data structure is supposed to be. This week we spoke with David Fisher and Greg Price about their work on Myp

Jul 10, 2016 • 1:00:20

BeeWare with Russell Keith-Magee

Summary When you have good tools it makes the work you do even more enjoyable. Russel Keith-Magee has been building up a set of tools that are aiming to let you write graphical interfaces in Python and run them across all of your target platforms. Most recently he has been working on a capstone project called Toga that targets the Android and iOS platforms with the same set of code. In this episode we explored his journey through programming and how he has built and designed the Beeware suite.

Jul 2, 2016 • 1:10:36

Armin Ronacher

Summary Armin Ronacher is a prolific contributor to the Python software ecosystem, creating such widely used projects as Flask and Jinja2. This week we got the opportunity to talk to him about how he got his start with Python and what has inspired him to create the various tools that have made our lives easier. We also discussed his experiences working in Rust and how it can interface with Python. Brief Introduction Hello and welcome to Podcast.__init__, the podcast about Python and the peop

Jun 26, 2016 • 1:00:21

Bandit with Tim Kelsey, Travis McPeak, and Eric Brown

Summary Making sure that your code is secure is a difficult task. In this episode we spoke to Eric Brown, Travis McPeak, and Tim Kelsey about their work on the Bandit library, which is a static analysis engine to help you find potential vulnerabilities before your application reaches production. We discussed how it works, how to make it fit your use case, and why it was created. Give the show a listen and then go start scanning your projects! Brief Introduction Hello and welcome to Podcast._

Jun 18, 2016 • 28:48

Sentry with David Cramer

Visit our site to listen to past episodes, support the show, join our community, and sign up for our mailing list. Summary As developers we all have to deal with bugs sometimes, but we don’t have to make our users deal with them too. Sentry is a project that automatically detects errors in your applications and surfaces the necessary information to help you fix them quickly. In this episode we interviewed David Cramer about the history of Sentry and how he has built a team around it to provide

Jun 12, 2016 • 1:09:28

Mercurial with Augie Fackler

Visit our site to listen to past episodes, support the show, join our community, and sign up for our mailing list. Summary As developers, one of the most important tools that we use daily is our version control system. Mercurial is one such tool that is written in Python, making it eminently flexible, customizable, and incredibly powerful. This week we spoke with Augie Fackler to learn about the history, features, and future of Mercurial. Brief Introduction Hello and welcome to Podcast.__in

Jun 5, 2016 • 55:12

Pillow with Alex Clark

Visit our site to listen to past episodes, support the show, join our community, and sign up for our mailing list. Summary If you need to work with images the Pillow is the library to use. The Python Image Libary (PIL) has long been the gold standard for resizing, analyzing, and processing pictures in Python. Pillow is the modern fork that is bringing the PIL into the future so that we can all continue to use it moving forward. This week I spoke with Alex Clark about what first led him to fork

May 28, 2016 • 20:01

Wagtail with Tom Dyson

Visit our site to sign up for the newsletter, explore past episodes, subscribe to the show, and help support our work. Summary If you are operating a website that needs to publish and manage content on a regular basis, a CMS (Content Management System) becomes the obvious choice for reducing your workload. There are a plethora of options available, but if you are looking for a solution that leverages the power of Python and exposes its flexibility then you should take a serious look at Wagtail

May 21, 2016 • 52:32

Buildbot with Pierre Tardy

Visit our site to listen to past episodes, support the show, join our community, and sign up for our mailing list. Summary As technology professionals, we need to make sure that the software we write is reliably bug free and the best way to do that is with a continuous integration and continuous deployment pipeline. This week we spoke with Pierre Tardy about Buildbot, which is a Python framework for building and maintaining CI/CD workflows to keep our software projects on track. Brief Introdu

May 14, 2016 • 1:25:08

Onion IoT with Lazar and Zheng

Visit our site to listen to past episodes, support the show, join our community, and sign up for our mailing list. Summary One of the biggest new trends in technology is the Internet of Things and one of the driving forces is the wealth of new sensors and platforms that are being continually introduced. In this episode we spoke with the founder and head engineer of one such platform named Onion. The Omega board is a new hardware platform that runs OpenWRT and lets you configure it using a numb

May 7, 2016 • 35:51

LibCloud with Anthony Shaw

Visit our site to listen to past episodes, support the show, join our community, and sign up for our mailing list. Summary More and more of our applications are running in the cloud and there are increasingly more providers to choose from. The LibCloud project is a Python library to help us manage the complexity of our environments from a uniform and pleasant API. In this episode Anthony Shaw joins us to explain how LibCloud works, the community that builds and supports it, and the myriad ways

May 1, 2016 • 1:24:34

Pip and the Python Package Authority with Donald Stufft

Visit our site to listen to past episodes, support the show, join our community, and sign up for our mailing list. Summary As Python developers we have all used pip to install the different libraries and projects that we need for our work, but have you ever wondered about who works on pip and how the package archive we all know and love is maintained? In this episode we interviewed Donald Stufft who is the primary maintainer of pip and the Python Package Index about how he got involved with th

Apr 23, 2016 • 52:59

StackStorm with Tomaž Muraus and Patrick Hoolboom

Visit our site to listen to past episodes, support the show, join our community, and sign up for our mailing list. Summary If you are responsible for managing any amount of servers, then you know that automation is critical for maintaining your sanity. This week we spoke with Tomaž Muraus and Patrick Hoolboom about their work on StackStorm, which is a platform for tracking and reacting to events in your infrastructure. By allowing you to register actions with event triggers it frees you from h

Apr 16, 2016 • 59:22

Hypothesis with David MacIver

Visit our site to listen to past episodes, support the show, join our community, and sign up for our mailing list. Summary Writing tests is important for the stability of our projects and our confidence when making changes. One issue that we must all contend with when crafting these tests is whether or not we are properly exercising all of the edge cases. Property based testing is a method that attempts to find all of those edge cases by generating randomized inputs to your functions until a f

Apr 9, 2016 • 47:01

Pyjion with Dino Viehland and Brett Cannon

Visit our site to listen to past episodes, support the show, join our community, and sign up for our mailing list. Summary In an attempt to improve the performance characteristics of the CPython implementation, Dino Viehland began work on a patch to allow for a pluggable interface to a JIT (Just In Time) compiler. His employer, Microsoft, decided to sponsor his efforts and the result is the Pyjion project. In this episode we spoke with Dino Viehland and Brett Cannon about the goals of the proj

Apr 1, 2016 • 1:10:26

Transcrypt with Jacques de Hooge

Visit our site to listen to past episodes, support the show, join our community, and sign up for our mailing list. Summary Any programmer who has dealt with a website for any length of time knows that writing JavaScript isn’t always the most enjoyable. Wouldn’t you rather write that code in Python and just have it work on your website? In this episode we learn about Transcrypt with its creator Jacques de Hooge. Transcrypt is a Python to JavaScript transpiler that embraces the JavaScript ecosys

Mar 26, 2016 • 42:10

VPython with Ruth Chabay and Bruce Sherwood

Visit our site to listen to past episodes, support the show, join our community, and sign up for our mailing list. Summary Wouldn’t it be nice to be able to generate interactive 3D visualizations of physical systems in a declarative manner with Python? In this episode we spoke with Ruth Chabay and Bruce Sherwood about the VPython project which does just that. They tell us about how the use VPython in their classrooms, how the project got started, and the work they have done to bring it into th

Mar 18, 2016 • 1:03:02

PyData London with Ian Ozsvald and Emlyn Clay

Visit our site to listen to past episodes, support the show, join our community, and sign up for our mailing list. Summary Ian Ozsvald and Emlyn Clay are co-chairs of the London chapter of the PyData organization. In this episode we talked to them about their experience managing the PyData conference and meetup, what the PyData organization does, and their thoughts on using Python for data analytics in their work. Brief Introduction Hello and welcome to Podcast.__init__, the podcast about P

Mar 12, 2016 • 1:03:11

Efene with Mariano Guerra

Visit our site to listen to past episodes, support the show, join our community, and sign up for our mailing list. Summary Efene is a language that runs on the Erlang Virtual Machine (BEAM) and is inspired by the Zen of Python. It is intended as a bridge language that serves to ease the transition into the Erlang ecosystem for people who are coming from languages like Python. In this episode I spoke with Mariano Guerra, the creator of Efene, about how Python influenced his design choices, why

Mar 4, 2016 • 59:35

Functional Python with Matthew Rocklin and Alexander Schepanovsky

Visit our site to listen to past episodes, support the show, join our community, and sign up for our mailing list. Summary What is functional programming, why would you want to use it, and how can you get started with it in Python? Our guests this week, Matthew Rocklin and Alexander Schepanovsky, help us understand all of that and more. Matthew and Alexander have each created their own Python libraries to make it easier to employ functional paradigms in your Python code. In this episode they h

Feb 29, 2016 • 1:20:02

Cython with Craig Citro and Robert Bradshaw

Visit our site to listen to past episodes, support the show, join our community, and sign up for our mailing list. Summary Do you find yourself reaching for a different language when you need some extra speed? With Cython you can get the best of both worlds by writing your code in Python and executing it as compiled code. In this episode we were joined by Craig Citro and Robert Bradshaw from the Cython project to discuss how and when you might want to incorporate it into your applications. Br

Feb 19, 2016 • 52:03

Airflow with Maxime Beauchemin

Visit our site to listen to past episodes, support the show, join our community, and sign up for our mailing list. Summary Are you struggling with trying to manage a series of related, interdependent batch jobs? Then you should check out Airflow. In this episode we spoke with the project’s creator Maxime Beauchemin about what inspired him to create it, how it works, and why you might want to use it. Airflow is a data pipeline management tool that will simplify how you build, deploy, and monito

Feb 13, 2016 • 1:03:17

WSGI 2

Visit our site to listen to past episodes, support the show, join our community, and sign up for our mailing list. Summary The Web Server Gateway Interface, or WSGI for short, is a long-standing pillar of the Python ecosystem. It has enabled a vast number of web frameworks to proliferate by not having to worry about how exactly to interact with the HTTP protocol and focus instead on building a library that is robust, extensible, and easy to use. With recent evolutions to how we interact with t

Feb 7, 2016 • 1:04:46

SymPy With Aaron Meurer

Visit our site to listen to past episodes, support the show, join our community, and sign up for our mailing list. Summary Looking for an open source alternative to Mathematica or MatLab for solving algebraic equations? Look no further than the excellent SymPy project. It is a well built and easy to use Computer Algebra System (CAS) and in this episode we spoke with the current project maintainer Aaron Meurer about its capabilities and when you might want to use it. Brief Introduction Hello

Jan 31, 2016 • 1:03:06

RPython with Maciej Fijalkowski

Visit our site to listen to past episodes, support the show, join our community, and sign up for our mailing list. Summary RPython is a subset of Python that is used for writing high performance interpreters for dynamic languages. The most well-known product of this tooling is the PyPy interpreter. In this episode we had the pleasure of speaking with Maciej Fijalkowski about what RPython is, what it isn’t, what kinds of projects it has been used for, and what makes it so interesting. Brief In

Jan 22, 2016 • 35:34

Ben Darnell on Tornado

Visit our site to listen to past episodes, support the show, join our Discourse community, and sign up for our mailing list. Summary If you are trying to build a web application in Python that can scale to a high number of concurrent users, or you want to leverage the power of websockets, then Tornado just may be the library you need. In this episode we interview Ben Darnell about his work as the maintainer of the Tornado project and how it can be used in a number of ways to power your next hi

Jan 16, 2016 • 1:06:28

Yves Hilpisch on Quantitative Finance

Visit our site to listen to past episodes, join our community Discourse, support the show, and sign up for our mailing list. Summary Yves Hilpisch is a founder of The Python Quants, a consultancy that offers services in the space of quantitative financial analysis. In addition, they have created open source libraries to help with that analysis. In this episode we spoke with him about what quantitative finance is, how Python is used in that domain, and what kinds of knowledge are necessary to d

Jan 8, 2016 • 1:10:30

Scott Sanderson on Algorithmic Trading

Visit our site to listen to past episodes, support the show, and sign up for our mailing list. Summary Because of its easy learning curve and broad extensibility Python has found its way into the realm of algorithmic trading at Quantopian. In this episode we spoke with Scott Sanderson about what algorithmic trading is, how it differs from high frequency trading, and how they leverage Python for empowering everyone to try their hand at it. Brief Introduction Hello and welcome to Podcast.__in

Jan 3, 2016 • 1:27:54

The PEP Talk

Visit our site to listen to past episodes, support the show, and sign up for our mailing list. Summary The Python language is built by and for its community. In order to add a new feature, change the specification, or create a new policy the first step is to submit a proposal for consideration. Those proposals are called PEPs, or Python Enhancement Proposals. In this episode we had the great pleasure of speaking with three of the people who act as stewards for this process to learn more about

Dec 27, 2015 • 1:45:42

Eric Holscher on Documentation and Read The Docs

Visit our site to listen to past episodes, support the show, and sign up for our mailing list. Summary The first place we all go for learning about new libraries is the documentation. Lack of effective documentation can limit the adoption of an otherwise excellent project. In this episode we spoke with Eric Holscher, co-creator of Read The Docs, about why documentation is important and how we can all work to make it better. Brief Introduction Hello and welcome to Podcast.__init__, the podca

Dec 20, 2015 • 1:05:34

Sylvain Thénault on ASTroid

Visit our site to listen to past episodes, support the show, and sign up for our mailing list. Summary The Python AST (Abstract Syntax Tree) is a powerful abstraction that allows for a number of innovative projects. ASTroid is a library that provides additional convenience methods to simplify working with the AST. In this episode we spoke with Sylvain Thénault from Logilab about his work on ASTroid and how it is used to power the popular PyLint static analysis tool. Brief Introduction Hello

Dec 12, 2015 • 47:29

Stuart Mumford on SunPy

Visit our site to listen to past episodes, support the show, and sign up for our mailing list. Summary What is Solar Physics? How does it differ from AstroPhysics? What does this all have to do with Python? In this episode we answer all of those questions when we interview Stuart Mumford about his work on SunPy. So put on your sunglasses and learn about how to use Python to decipher the secrets of our closest star. Brief Introduction Hello and welcome to Podcast.__init__, the podcast about

Dec 4, 2015 • 40:38

Maneesha Sane on Software and Data Carpentry

Visit our site to listen to past episodes, support the show, and sign up for our mailing list. Summary The Software and Data Carpentry organizations have a mission of making it easier for scientists and data analysts in academia to replicate and review each others work. In order to achieve this goal they conduct training and workshops that teach modern best practices in software and data engineering, including version control and proper data management. In this episode we had the opportunity t

Nov 25, 2015 • 44:29

Erik Tollerud on AstroPy

Visit our site to listen to past episodes, support the show, and subscribe to our mailing list. Summary Erik Tollerud is an astronomer with a background in software engineering. He leverages these backgrounds to help build and maintain the AstroPy framework and its associated modules. AstroPy is a set of Python libraries that provide useful mechanisms for astronomers and astrophysicists to perform analyses on the data that they receive from observational equipment such as the mountain observat

Nov 20, 2015 • 49:19

Dariusz Suchojad on Zato

Visit our site to listen to past episodes, support the show, and sign up for our mailing list. Summary Service integration platforms have traditionally been the realm of Java projects. Zato is a project that shows Python is a great choice for systems integration due to its flexibility and wealth of useful libraries. In this episode we had the opportunity to speak with Dariusz Suchojad, the creator of Zato about why he decided to make it and what makes it interesting. Listen to the episode and

Nov 13, 2015 • 42:27

Tom Rothamel on Ren’Py

Visit our site to listen to past episodes, support the show, and sign up for our mailing list. Summary Tom Rothamel is an embedded systems engineer who spends his free time working on Ren’Py, a visual novel engine written in Python. Ren’Py allows you to write interactive fiction experiences and deploy them across desktop and mobile platforms. By creating a purpose-built DSL for describing the interactions, users of Ren’Py can focus on crafting polished experiences without fighting through the

Nov 6, 2015 • 58:52

Anthony Scopatz on Xonsh

Visit our site to listen to past episodes, support the show, and sign up for our mailing list. Summary Anthony Scopatz is the creator of the Python shell Xonsh in addition to his work as a professor of nuclear physics. In this episode we talked to him about why he created Xonsh, how it works, and what his goals are for the project. It is definitely worth trying out Xonsh as it greatly simplifies the day-to-day use of your terminal environment by adding easily accessible python interoperability

Oct 31, 2015 • 57:54

Kay Hayen on Nuitka

Visit our site to listen to past episodes, support the show, and sign up for our mailing list. Summary Kay Hayen is a systems engineer from Germany who has dedicated his spare time to the creation of Nuitka, a library that will compile your Python project to C++. In this episode we talked to Kay about what inspired him to create the project, how it operates, and some of the challenges he has faced. It is a very interesting project and it has the potential to let you run your Python code in a w

Oct 24, 2015 • 1:34:35

Trent Nelson on PyParallel

Visit our site to listen to past episodes, support the show, and sign up for our mailing list. Summary Trent Nelson is a software engineer working with Continuum Analytics and a core contributor to CPython. He started experimenting with a way to sidestep the restrictions of the Global Interpreter Lock without discarding its benefits and that has become the PyParallel project. We had the privilege of discussing the details around this innovative experiment with Trent and learning more about the

Oct 14, 2015 • 1:12:43

Dag Brattli on RxPy

Visit our site to listen to past episodes, support the show, and sign up for our newsletter! Summary Dag Brattli is an engineer with Microsoft and in his spare time he created the ported the Reactive Xtensions framework to Python in the form of the RxPy library. In this episode we had the opportunity to speak with Dag and learn more about what ReactiveX is, why it is useful and how you can use it in your Python programs. It is definitely a very powerful programming patern when manipulating dat

Oct 9, 2015 • 33:02

uWSGI Core Developers

Visit our site to listen to past episodes, join the mailing list and support the show. Summary uWSGI is one of the most versatile application servers available. It was originally written for running Python applications and has since gained functionality to support Perl, Ruby, PHP, and more in addition to the incredible feature set. In this episode Tobias got to interview three of the core developers of this project and find out more about how the different pieces of it fit together and what it

Oct 3, 2015 • 35:00

Griatch on Evennia (Making MUDs with Python)

Visit our site to listen to past episodes, sign up for our mailing list and support the show. Summary Griatch is an incredibly talented digital artist, professional astronomer and the maintainer of the Evennia project for creating MUDs in Python. We got the opportunity to speak with him about what MUDs are, why they’re interesting and how Evennia simplifies the process of creating and extending them. If you’re interested in building your own virtual worlds, this episode is a great place to sta

Sep 29, 2015 • 1:14:03

Hylang Core Developers

Visit our site to listen to past episodes, support the show, and sign up for our mailing list Summary We got the chance to talk to some of the core developers of Hylang, which is a Lisp dialect that runs on the Python VM! We talked about how it got started, how it works and why you should try it. Of particular interest is our discussion about using Hylang to backport language features, or create entirely new ones due to the power of Lisp and the Python AST (Abstract Syntax Tree). If you need t

Sep 19, 2015 • 55:48

Bryan Van de Ven on Bokeh

Visit our site to listen to past episodes, subscribe to our mailing list, and donate to the show. Summary Bryan Van de Ven is the project maintainer for Bokeh, a plotting and visualization toolkit that allows Python developers to easily create attractive interactive visualizations for the web. We talked about the project’s history, some interesting use cases for it, and what its near future looks like. Bryan also told us about how Bokeh compares to some of the other visualization libraries in

Sep 8, 2015 • 57:19

Jessica McKellar

Visit our site to listen to past episodes, support the show and sign up for our mailing list. Summary We got the chance to talk to Jessica McKellar about her work in the Python community. She told us about her experience as a director for the PSF, working as the diversity outreach manager for PyCon, and being a champion for improving the on-boarding experience for new users of Python. We also discussed perceptions around the performance of Python and some of the work being done to improve conc

Sep 1, 2015 • 51:24

Static Site Generators with Justin Mayer and Roberto Alsina

Visit our site to listen to past episodes, comment on the show or find out more about us. Summary In this episode we had the opportunity to discuss the world of static site generators with Roberto Alsina of the Nikola project and Justin Mayer of the Pelican project. They explained what static site generators are and why you might want to use one. We asked about why you should choose a Python based static site generator, theming and markup support as well as metadata formats and documentation.

Aug 25, 2015 • 1:32:36

Al Sweigart on Python for Non-Programmers

Visit our site to listen to past episodes, learn more about us, and support the show. Summary We got the opportunity to speak with Al Sweigart about his work on books like ‘Automate The Boring Stuff With Python’ and ‘Invent With Python’. We discussed how Python can be useful to people who don’t work as software engineers, why coding literacy is important for the general populace and how that will affect the ways in which we interact with software. Brief Introduction Hello and welcome to Pod

Aug 16, 2015 • 52:52

Liza Avramenko on CheckIO and Empire of Code

Visit our site to listen to past episodes, find additional content, sign up for our newsletter or learn about the hosts. Summary In this episode we talked to Liza Avramenko, the CEO of CheckIO, about Empire of Code and CheckIO. We discussed what differentiates them from each other and from the other coding games that have been spreading on the internet. One of the main differentiators for CheckIO in particular is the strong focus on community. The bottom line is that if you use Python then you

Aug 6, 2015 • 48:15

Glyph on Ethics in Software

Visit our site for past episodes and extra content. Summary In this episode we had a nice long conversation with Glyph Lefkowitz of Twisted fame about his views on the need for an established code of ethics in the software industry. Some of the main points that were covered include the need for maintaining a proper scope in the ongoing discussion, the responsibilities of individuals and corporations, and how any such code might compare with those employed by other professions. This is somethin

Aug 3, 2015 • 1:19:23

Holger Krekel on Py.Test

Visit our site to listen to past episodes, learn more about the show and sign up for our mailing list. Summary In this episode we talked to Holger Krekel about the py.test library. We discussed the various styles of testing that it supports, the plugin system and how it compares to the unittest library. We also reviewed some of the challenges around packaging and releasing Python software and our thoughts on some ways that they can be improved. Brief Introduction Welcome to Podcast.__init__

Jul 24, 2015 • 1:11:00

Damien George Talks To Us About MicroPython

Visit our site for more news, information and past episodes of Podcast.__init__! Summary We talked to Damien George about his work on the Micro Python interpreter and the PyBoard SOC (Systom On a Chip). The combination of the interpreter and SOC allows Python developers to get involved in hardware hacking, as well as letting electronics afficionados try their hand at development. Damien explained to us where this fits in with the expanding landscape of low cost embedded devices and why you sho

Jul 16, 2015 • 49:18

Allen Downey on Teaching Computer Science with Python

Find past episodes and more information about the show at iTunes, Stitcher or TuneIn Give us feedback! (iTunes, Twitter, email, Disqus comments) You can donate (if you want) Overview – Interview with Allen Downey, Prolific Author and Professor of Computer Science Interview with Allen Downey Introductions How did you get introduced to Python? – Chris Wrote a Java book with an open license to allow anyone to make changes Jeff Elkner translated it to Python What attributes of Py

Jul 9, 2015 • 37:42

Jacob Kovac on KivEnt

Listen to past episodes and find out more about the show at our website pythonpodcast.com Synopsis In this episode we talked to Jacob Kovac, creator of the KivEnt game engine and one of the Kivy core developers. He told us about what inspired him to create the KivEnt project, some of the ways that he has managed to optimize rendering time and some of the problems that he has encountered as part of his work on the project. We also discussed what the use cases and limitations of the KivEnt engin

Jul 3, 2015 • 1:08:42

Eric Schles on Fighting Human Trafficking with Python

Listen to past episodes, read about the hosts or donate to the show at podcastinit.com Brief Introduction Date of recording – June 10th, 2015 Hosts Tobias Macey and Chris Patti Follow us on iTunes, Stitcher or TuneIn Give us feedback! (iTunes, Twitter, email, Disqus comments) You can donate (if you want)! Overview – Interview with Eric Schles Interview with Eric Schles Introductions How did you get introduced to Python? What inspired you to take up the fight against slavery? I

Jun 25, 2015 • 1:13:10

Naomi Ceder, Lynn Root and Tracy Osborn on Diversity in the Python Community

Listen to past episodes, read about the show and check out our donations section at podcastinit.com Brief Introduction Date of recording – Jun-10th, 2015 Hosts Macey and Chris Patti Follow us on iTunes, Stitcher or TuneIn Give us feedback! (iTunes, Twitter, email, Disqus comments) You can donate (if you want)! Overview – Interview with Tracy Osborn, Naomi Ceder, Lynn Root Interview with Prominent PyLadies Introductions Tracy Osborn Naomi Ceder Lynn Root How did you get int

Jun 18, 2015 • 49:15

Brian Granger and Fernando Perez of the IPython Project

You can find past episodes and other information about the show at podcastinit.com Brief Introduction Date of recording – June 3rd, 2015 Hosts – Tobias Macey and Chris Patti Overview – Interview with Fernando Perez and Brian Granger, core developers of IPython/Project Jupyter Follow us on iTunes, Stitcher or TuneIn Give us feedback! (iTunes, Twitter, email, Disqus comments) You can donate (if you want)! Interview with Brian Granger and Fernando Perez Introductions How di

Jun 13, 2015 • 1:21:48

David Baumgold on Flask-Dance, WebhookDB and Open EdX

You can find out more about us and view previous episodes at podcastinit.com. Brief Introduction Date of recording – 2015-06-02 Hosts – Tobias Macey and Chris Patti Follow us on – iTunes, Stitcher or TuneIn Give us feedback on iTunes, Twitter, email or Disqus Interview with David Baumgold Introduction How did you get introduced to Python? What problem does Flask-Dance solve that wasn’t covered by other libraries? What were some of the technical issues that you encountere

Jun 7, 2015 • 32:21

Mark Baggett on Python for InfoSec

Read all of our show notes and find more information about us at Beautiful Soup Brief Introduction Date of recording – May 28th, 2015 Hosts – Tobias Macey and Chris Patti Overview – Interview with Mark Bagett Follow us on iTunes, Stitcher or TuneIn Give us feedback! (iTunes, Twitter, email, Disqus comments) You can donate (if you want)! Interview with Mark Bagett Introductions How were you first introduced to Python? – Chris Started using it for automating tasks w

Jun 3, 2015 • 1:14:31

Jacob Kaplan-Moss on Addressing Cultural Issues in Tech

Read all of our show notes and find more information about us at podcastinit.com Brief Introduction Date of recording – May 18th, 2015 Hosts – Tobias Macey and Chris Patti Follow us on iTunes, Stitcher or TuneIn Give us feedback! (iTunes, Twitter, email, Disqus comments) Overview – Interview with Jacob Kaplan-Moss Interview with Jacob Kaplan-Moss Introductions How were you first introduced to Python? So, we wanted to invite you on the show to discuss the keynote that you

May 26, 2015 • 49:36

Jonathan Slenders Talks About Prompt Toolkit

Visit our site at podcastinit.com for more show notes and news. Brief Introduction Date of recording – May 17th, 2015 Hosts – Tobias Macey and Chris Patti Follow us on iTunes, Stitcher or TuneIn Give us feedback! (iTunes, Twitter, email, Disqus comments) Overview – Interview with Jonathan Slenders Interview with Jonathan Slenders Introductions How were you first introduced to Python? -Chris What inspired you to create the python-prompt-toolkit? What are some design consider

May 19, 2015 • 40:54

Ned Batchelder

Visit podcastinit.com for information about the show and links to our iTunes and Stitcher feeds. Brief Introduction Date of recording – May 4th, 2015 Hosts – Tobias Macey and Chris Patti Overview – Interview with Ned Batchelder Follow us on iTunes, Stitcher or TuneIn Give us feedback! (iTunes, Twitter, email, Disqus comments) You can donate (if you want)! Interview with Ned Batchelder Introductions How did you get introduced to Python? Zope … Implemented in Python Ho

May 12, 2015 • 1:15:55

Travis Oliphant

For show notes and other content, visit our site at http://www.pythonpodcast.com?utm_source=rss&utm_medium=rss Brief Introduction Date of recording – Apr 28th 2015 Hosts – Tobias Macey and Chris Patti Overview – Interview with Travis Oliphant Interview with Travis Oliphant Introductions How did you get introduced to Python? I’m curious what inspired you to create NumPy and SciPy? Why did you choose Python for those libraries? Numeric, Jim Hugunin Morphology library in N

May 4, 2015 • 52:17

Kivy Core Developers

You can view all of the show notes for every episode at http://podcastinit.com?utm_source=rss&utm_medium=rss Brief Introduction Date of recording – Apr 21st 2015 Hosts – Tobias Macey and Chris Patti Overview – Interview with members of the Kivy core development team Interview with Kivy Core Developers Introductions How did you get introduced to Python? How did the Kivy project get started? What made you choose Python as the basis for Kivy? What were some influences on an

Apr 27, 2015 • 1:30:33

Reuven Lerner

Full show notes can be found at http://podcastinit.com/episode-2-reuven-lerner.html?utm_source=rss&utm_medium=rss Episode 2 Brief intro Recording date/time Hosts Overview Reuven Lerner Interview Please introduce yourself How did you get introduced to Python? How did you break into the field of providing Python trainings? What are the most common languages that your students are coming from? What are some of the biggest obstacles that people encounter when learning Python? Where does

Apr 23, 2015 • 1:07:31

Thomas Hatch

Full show notes can be found at http://podcastinit.com/episode-1-thomas-hatch.html?utm_source=rss&utm_medium=rss Brief Intro Hosts Overview Python at Chefconf! Plug for Talk Python To Me Thomas Hatch Interview Picks Thomas Hatch Flow Based Programming IOFlo Imagine Dragons Chris Patti Stone Imperial Russian Stout Python One Liner Games Boston Python User Group Tobias Macey Noisli CopyQ Pelican Moving From Heroku to AWS With Salt Part 1 Moving From Heroku to AWS With Salt Pa

Apr 11, 2015 • 1:06:51

Podcast.__init__ - Introduction

Welcome to the first episode of a new podcast focused on bringing you the stories of the people who make the Python language and ecosystem great.OutlineIntroductionBrief Host BiographiesWhy We’re Doing ThisWhy We Love Python & Favorite ToolsThank YouPicks!PicksTobiasSummoner WarsDbeaverKDE ConnectPlayerctlChris ptpythonDuchesse de BourgogneThe intro and outro music is from Requiem for a Fish (The Freak Fandango Orchestra) / CC BY-SA 3.0

Mar 21, 2015 • 27:24