pre-release: North Bay Python meeting announcement

Please take a moment to review your details and reply with OK or edits.
Subject and below is what will go out and also will be used to title the videos.

Subject: 
ANN: North Bay Python at Mystic Theatre Sat December 2, 10p


North Bay Python
=========================
When: 10 AM Saturday December 2, 2017
Where: Mystic Theatre
About North Bay Python

A single-track conference north of the Golden Gate, focused on community, collaboration, and all things Python.

North Bay Python is a two-day, single-track Python conference held at the Mystic Theatre in Historic Downtown Petaluma, California, over the weekend of December 2 & 3, 2017.

We're a nonprofit conference for professionals, enthusiasts and students alike. We're focused on inclusion, accessibility, diversity, and affordability. Most importantly, we're planning a great lineup of talks from all over the Python ecosystem, with plenty of time to meet new people and develop new ideas.

Our venue, the Mystic Theatre in Downtown Petaluma, is a beautiful example of an early 1900s Vaudeville theatre. You can find over 50 different food and drink options a short walk away, and the nearest hotel is only a block away.
https://2017.northbaypython.org/

Topics
------
1. Conference Opening


(Needs description.) 
 recording release: yes license: CC BY  

2. Keynote
Brandon Rhodes

Keynote presentation from North Bay Python 2017 by Brandon Rhodes
 recording release: yes license: CC BY-SA  

3. How Unreliable Computers Can Usually Agree (Sort Of): A Brief Tour of the Raft Algorithm
Laura Hampton

Every day, the amount of data we store increases dramatically. Users demand high availability and low latency from the machines where it is stored. Single machines are prone to failure, and in many cases can't cope with high traffic demands. Distributed systems have become an increasingly common solution for these problems. They offer fault tolerance and resilience while allowing users to interact with what appears to be a single machine.

The talk is intended for people who are curious about distributed systems and who would like a better understanding of how they work. Attendees will come away with an understanding of the problem of consensus, what problems consensus algorithms solve, and how the Raft algorithm works.
 recording release: yes license: CC BY-SA  

4. Why does Python need security transparency?
Steve Dower

The days of "software vulnerability" being a synonym for "buffer overflow" are over. Modern vulnerabilities are those that enable attackers to get into your network and stay in your network. Beyond simple bugs, any tool that can execute arbitrary code becomes a vulnerability - _especially_ if you don't know when it is doing that.

Python is a popular tool with attackers, in large part because it can download encrypted code, decrypt and execute it with a single line of code. And once that entire payload is running, nobody knows exactly what it is doing.

[PEP 551](https://www.python.org/dev/peps/pep-0551/) adds a range of auditing hooks to the Python runtime, enabling system administrators to see into how it is being used. You can inspect every piece of code that is compiled and executed, intercept calls that modify trace functions, and collect information on code that uses native functions through `ctypes`.

This session will look at why we need security transparency in Python. We will look at actual examples of malware written in Python, and see how the hooks provided by PEP 551 enable administrators to detect and prevent attacks on their systems.
 recording release: yes license: CC BY-SA  

5. Loop better: a deeper look at iteration in Python
Trey Hunner

What's the difference between an iterable, an iterator, and a generator?  Do you know how to create infinitely long iterables?
 Come to this talk to learn some of Python's slightly more advanced looping techniques.

Iterables are a very big deal in Python and they became even more important in Python 3.  There's quite a bit beyond the basics when it comes to loops and looping in Python.  Let's learn some of Python's slightly more advanced looping techniques!

In this session, we'll take a step back and learn about how looping actually works in Python.  We'll then learn about a number of Python looping techniques that you've probably overlooked.

We'll learn about the difference between sequences, iterables, and iterators.  We'll also reveal the iterator protocol that powers `for` loops in Python.

After we learn the basics, we'll learn some techniques for working with infinite infinite iterables, generators, and generator expressions.

Attendees will walk away from this session with specific actionable recommendations for refactoring their own code as well as a wealth of new topics to look deeper into after the session.
 recording release: yes license: CC BY-SA  

6. I Finished the Beginner Tutorial, Now What?
Kelsey Karin Hawley

This talk will cover 3 different learning styles that I have experienced and observed for where to go after finishing a beginner tutorial (like CodeAcademy).

**Learning through practice or exercise based learning.**  This section would focus on websites useful for building up skills and comfort in a language (resources like HackerRank, Project Euler, etc).  It would also provide resources for getting feedback on code, like exercism.io

**Learning through others or vicariously.** This section would focus on tips for finding open source projects that can be read through.  This would discuss reading through another's code, how to look up concepts or libraries that are new, and how to work on existing bugs.  This might also give tips on breaking another's code to better understand how it works and how it could be improved.

**Project based Learning.** This section would focus on tips for managing a project based approach - not biting off more than you can chew, breaking an idea down into managable pieces, and not getting discouraged.  This would also cover tools like Stack Overflow and language communities that can be used when a person gets stuck on a bug or needs ideas on how to solve a problem.

**Get Connected.**  This section would discuss various groups and communities (PyLadies, meetups, etc) that can be used for networking and growing knowledge.  I will also discuss finding a mentor, either at your current place of work, or from within a community group.  As a mentor, I'll talk about things to look for in a mentor and what a mentee can hope to gain from that relationship.

To summarize, I'll reiterate the three different learning styles while reinforcing there is no right or wrong way to brige the gap between Hello World and building a web app.  I'll also summarize the various resources along the way (HackerRank, PyLadies, mentorship).
 recording release: yes license: CC BY-SA  

7. Async for the Python 2 Programmer
Henry Chen

# Background

* Why async? CPU bound vs IO bound processes.
* Concurrency is not the same as multithreading
* Single threaded concurrency

# Generators - already in Python 2 !

* Generator - a function you can pause!
* How to implement async with generators and event loop in Python 2
* Real working code - a Python version of the JavaScript setTimeout function

# What is new in Python 3 ?

* async/await - really generators in disguise!
* asyncio library - ready made event loop and IO functions
* new syntax and new library are independent - you can mix and match old and new!
 recording release: yes license: CC BY-SA  

8. Python (and Fortran and C) as used in large-scale number crunching and scientific programming
Catherine Moroney

Python is an incredibly powerful and versatile language, but it is not practical for lots of deeply nested loops because it's not compiled, and a lot of the big scientific libraries only have C interfaces.  But, if you bring Fortran (via f2py) and C (Cython) into the mix then you can use the best features of all three languages and shrink your development/maintenance time and resulting code size by almost an order of magnitude.

My satellite has a lot of legacy code in a Perl/C/Fortran mixture that is incredibly difficult to read and maintain, but our new software is in a Python/C/Fortran mixture (with Python being the bulk of the code) that is a fraction of the size of the old code, much much easier to develop and maintain, yet it has the speed and stability to be used in our production system.  

I use Python for the upper and middle layers, Fortran for the few places where I need to do lots of looping that cannot be transformed into whole-array operations, and then C to interface with the various 3rd party libraries.   I can wrap Fortran and C using f2py and Cython respectively, call them directly from the Python, and pass numpy arrays back and forth seamlessly.

I also have layers of scripts:  a Python code to run a single orbit's worth of data through a single stage of the processing pipeline,  a second Python script to run multiple orbits through a single stage, and then a third script that runs the entire processing chain through many orbits, thereby using Python's numerous scripting capabilities.  

By using all three languages as described above, I truly get the best of all worlds:  dramatically reduced development time, a code base that is a fraction of the size of the old legacy system, yet all the speed and stability I need to process huge amounts of data.
 recording release: yes license: CC BY-SA  

9. Stumbling Through Django and How Not To
Melanie Crutchfield

If you’re a beginner about to embark on a new Django project adventure, this talk is for you.

When I started my first Django project, I took the “Sure, I think I can figure that out” approach, which is fun! And also dangerous. But exciting! And also horrible because I caused myself a lot of trouble and barfed on my keyboard. (Metaphorically.) Oops.

My hope for this talk is to pass along lessons I learned the hard way, and save the world. Or at least prevent some frustration. :) 

We’ll talk about:

- version control
- structuring your project
- and how to handle top secret stuff. 

We’ll also talk about: 

- throwing house parties without causing anaphylaxis
- pregnant daddy seahorses
- velociraptors 
- and friends. 

I promise all of that is related to Django.
 recording release: yes license: CC BY-SA  

10. What is this machine learning thing, anyway?
George Brocklehurst

This talk will introduce a machine learning technique called linear regression, in a way that's targeted at working developers, not mathematicians or theoretical computer scientists. Want to get started with machine learning? This is how. Many of the principles of linear regression apply to other machine learning techniques, so the ground we cover today will set you up to explore the wider world of machine learning.
 recording release: yes license: CC BY-SA  

11. 5 Leadership Skills Every Engineer Needs
Kathleen Vignos

1.  Speaker intro

2.  Why does leadership matter for non-managers?

3.  Audience participation: what about leadership?

4.  Top concerns

    *   Using audience input and survey data from over 100 senior software engineers, we’ll discuss the top concerns related to leadership and working effectively with teams.  

5.  Methodology

6.  Explore leadership skills

7.  Resources
 recording release: yes license: CC BY-SA  

12. Colossal Cave Adventure in Python
Christopher Swenson

The oldest known Colossal Cave source code we have is from 1977 and written for the then 11-year-old PDP-10 in a variant of FORTRAN IV that is now completely defunct and was specific to the PDP-10.

We'll talk briefly about a history of video games, FORTRAN, and the PDP machines that led to this, and explain how the quirks of this machine were baked into its variant of FORTRAN IV. We'll look at some ancient PDP manuals to discover the secrets you need to know to read this amazing source code.

We'll delve into how one goes about writing a simple interpreter in Python to run this FORTRAN IV code as-is: translating strings, implementing its odd arithmetic and conditional statements, reading in data from our "tape" drive, how we get input and send output using our "teletype".

If you want a demo of this game playing right now, it is running on Heroku and accessible via SMS. Just text anything to +1 (669) 238-3683 ("669 ADVENT3") to start a game. Send RESET to restart the game. Case doesn't matter when sending commands. It identifies you based on your phone number and will remember your game indefinitely. (We'll also talk about how we achieved this in Heroku.)
 recording release: yes license: CC BY-SA  

13. Sunday Housekeeping


(Needs description.) 
 recording release: yes license: CC BY  

14. 2FA Mind
Carina C. Zona

2FA Mind

2-Factor Authentication (2FA) empowers people to better protect their online accounts. With daily revelations of mass data breaches, habitual use of 2FA has become vital for anyone whose accounts have access to private or confidential information.

Nevertheless, the vast majority of ordinary people still aren't using it! There are myths that 2FA is difficult to set up and use, or is only needed by high profile people who are personally targeted. Often users hold back because they perceive 2FA as difficult, complicated, or stressful. Already put off by ever-more-convoluted rules for picking a password, many people expect setting up 2FA to be even more daunting.

The great news is, we can fix this! Newer 2FA methods are making logging in quicker, simpler, and far more secure for users. Meanwhile, 2FA libraries have become widely available in Python and other major programming languages.

To kick off wider adoption of 2FA, we need a fresh mindset about it. Because in fact there's little that’s novel about 2FA. Each of us already has had years of everyday experience with the core concepts and mindset that are 2FA's foundation.

Together, we can build momentum for broad access to the security wins of 2FA. In this session, you'll discover the simple concepts at the heart of 2FA. You’ll learn about some common 2FA implementation approaches, and you’ll come away with a list of actions any of us—no matter what skill level—can take right now to help make the world a safer place for at least one vulnerable person.
 recording release: yes license: CC BY-SA  

15. Call C code quickly and compatibly with CFFI
Zack Voase

Have you ever wanted to speed up a slow part of your Python program by rewriting part of it in C? Maybe you needed to use a C/C++ library, but couldn’t find a Python binding? This talk will get you started with CFFI, a modern approach to calling into C code from Python. CFFI (FFI stands for ‘foreign function interface’) produces modules that work across interpreters and language versions. You won't need to write wrappers in a third language like SWIG or Cython, and you'll get better performance than with ctypes.

I'll walk through the creation of a library which wraps a C data structure, showing tips and tricks for rapid development, and how to avoid potential pitfalls. I'll also touch on how to interface with system libraries from Python, using CFFI to generate safe and fast bindings.
 recording release: yes license: CC BY-SA  

16. A Young Twitter Bot's Illustrated Primer (ebook)
Benno Rice

I run a Twitter bot that's aimed to be amusing. It generates tweets based off a mixture of other Twitter feeds, Facebook posts and some other sources. One of the challenges in making this work has been getting decently amusing output.

This presentation will go through some of the options available, ranging from simple Markov systems using markovify, through more complicated Markov approaches and will then look at systems based on torch-rnn and other neural network systems.

You'll leave this presentation with a decent overview of the ways you can transform content into new content and the strengths and weaknesses of each.
 recording release: yes license: CC BY-SA  

17. Mypy-thon gives you wings!
Henry Tanner

As your python project grows and the number of contributors increases, the stability,  readability and usability of your code-base can diminish. The once expressive experience of a single author writing dynamically typed Python can turn into a real headache as the complexity of your system develops.

But Python can still be a great choice for large applications - the library’s for scientific applications and web API’s are well documented, open-source and have been in development for decades. Mypy is a tool that (pretty much) allows you to have your cake and eat it. By combining the convenience and maturity of Python with a powerful type system and compile-time checking, you can make your project incredibly easy to read, debug and test for all contributors.

My talk will summarise the main features of Mypy and will also give you a head start on how to convert (and maintain) an existing code-base to include static annotations.
 recording release: yes license: CC BY-SA  

18. Obeying the Testing Goat: Building a test loving culture at your company
Julia Duimovich

We all know we should test our code. We all know that we should have a hypothetically perfectly tested codebase. But how many people actually do? Why don't we? What's stopping us? We'll talk about the skills and mentality everyone needs to have, the infrastructure that cuts down on the amount of work that you need to do to write a test, directly influencing how many of your coworkers actually write comprehensive tests. We'll also talk about planning and the torturous process of accepting what you can't test. You'll leave this talk planning to add an onboarding session dedicated to testing, excited about test infrastructure such as factories, and looking forward to the day that you discover the tests are there, and they can help you understand the code's structure and intended usage.
 recording release: yes license: CC BY-SA  

19. Nutshell in a Python: Adapting patterns from shell scripts
Brett Smith

This talk will illustrate common patterns for writing efficient process pipelines with the subprocess module; automatically checking for errors in those pipelines; and catching those errors and reporting them to the user in a standard way by defining a custom excepthook.  Used together, they'll give your script behavior more like a polished command line tool, without any serious rearchitecting.  Each of these patterns is straightforward and has no dependencies outside Python's standard library, so they're easy to use in both new and existing scripts.
 recording release: yes license: CC BY-SA  

20. Accessibility Matters: Creating a Better Web
Lindsey Dragun

Accessibility is a huge topic that is often acknowledged as important...by the people who already care about it. This talk is meant to help the entire audience start thinking about accessibility and realize how easy it is to at least put some accessibility into a site (or avoid adding blatantly inaccessible content).

According to the U.S. Census Bureau, around 19% of Americans have a disability, which is a large potential audience for any site. Many companies also fall under accessibility laws they might not even be aware cover their products, with lawsuits becoming more prevalent in recent years, and showing a good faith effort to improve your products’ accessibility can help keep your company out of hot water. Accessible web development also tends to lead to better UX and a happier user base. And, another plus: It will save devs time and frustration when they’re working with the code, since good HTML is enforced.

This talk will start with a broad introduction to accessibility, how to break different concerns down into categories for consideration, and touch on the US laws and recent legal outcomes around accessibility. The second part will go through examples of good and bad accessibility and what to look out for, as well as ways to improve accessibility (including "easy wins" that they could implement quickly to drastically improve their sites). The final section will include resources for finding accessibility standards and also browser extensions and the like for people to check on their own.

The audience will be expected to have working knowledge of the internet, webpages, and using webpages.
 recording release: yes license: CC BY-SA  

21. Search-First Writing for Developers
Heidi Waterhouse

Technical writing, in all its variations, is a type of interface with your product. It incorporates everything from an error message to an implementation guide. How can you as a developer make deploying, using, and promoting your product as painless as possible? Make it searchable. Make finding the answer to a problem so trivially easy that your user barely even remembers they had a problem.
 recording release: yes license: CC BY-SA  

22. On Quiet Developers
Seán Hanson

Trigger Warnings: discussion of workplace discrimination, mentions of physical and mental health

Open Source contributions are one of the most common de facto means to judging the competency of engineers, despite frequently resulting in the further marginalization of already marginalized people. In this talk, I’ll coin the term “Quiet Developer” for developers who are active, engaged, but to the eyes of many completely invisible for many reasons. I’ll dive into how developers like us survive, how hiring practices around us need to change, what employers can do to empower us, and in doing so finally chip away at the monolithic idea of “community engagement”, highlighting instead the many less-visible communities so many of us are part of.
 recording release: yes license: CC BY-SA  

23. import madness # how to implement mergesort from scratch using only import statements
George London

Recently I had trouble importing a module. So I started actually reading the documentation of the Python import system and realized that I had been writing Python for years without understanding basics like “a module is a file” or “importing a module executes it”.

A few days later I had a terrible realization – it’s possible to implement a mergesort algorithm in Python using only the import statement.

Actually making it work requires learning (and subverting) almost all of the import system’s underlying machinery. So walking through how it’s done creates an excellent (and entertaining) opportunity to shine some light on the darker corners of a system that Python programmers use nearly every day but can work for years without ever really understanding.

This talk starts off with an explanation of the basic fundamentals of the import system, i.e.

1) What does the word “module” actually mean? 
2) How does Python find the source code I’m importing? 
3) What is Python actually doing when I import code? How is it different from compiled languages?
4) How Python uses namespaces to manage scope and keep our functions and variables organized!

From there, things get pretty weird.

The rest of the talk explains how the import system alone gives us the tools to emulate function evaluation and how that means that we can (but shouldn’t!) write algorithms using import statements instead of functions.

I describe the classic mergesort algorithm and then I show how to actually implement it using imports (under the theory that nothing helps retain knowledge like watching it applied to a trainwreck.)

I briefly discuss how “computation” is an abstract process that can be accomplished in more ways that we might intuitively realize. And then I wrap up with some practical advice on how users can avoid ImportErrors and a warning about the serious but non-obvious security risks of importing Python code.
 recording release: yes license: CC BY-SA  

24. Running Vintage Software: PyPI's Aging Codebase.
Ernest W. Durbin III

From it's origins in the early days as a metadata server to the current trove of hosted packages, PyPI has grown into a critical part of the Python Communities Infrastructure.

Originally conceived and implemented in 2002 as a simple set of metadata, the codebase that backs PyPI has been pushed well beyond it's limits. While some may call it "legacy" software, I choose to view it like one may view a classic car that still sees it's time on the road.

This talk will present some of the challenges common to keeping a Vintage Car on the road as well as their counter parts when dealing with Vintage Software and take a look at the approaches that have worked well to keep PyPI up and running as a full rewrite is underway.

Also covered will be an overview of the history of PyPI as a whole, as well as what the future holds and how you (yes you!) can contribute.

Technical Topics covered include:

- External caching, Content Delivery Networks
- Internal caching, to speed up common or repetitive requests which just can't be cached in the CDN
- Metrics, Metrics, Metrics! Not just for monitoring! Keep track of what features just aren't worth supporting any longer or what methods are prime for optimization
- Dealing with issues related to scaling even when major refactors or changes aren't feasible.
- Increasing reliability

The desired outcome for attendees of this talk is a sense of how to approach a Vintage codebase that must remain up and running even as it's predecessor may be in progress. Big rewrites can take time! Don't feel defeated sustaining an old project, it is what your users need!

Novice attendees may find the history and high level concepts interesting, but Intermediate attendees should get the most out of this talk. Specifically some of the technical bits will make the most sense and be most applicable if you've ever worked on a medium to large production web service.
 recording release: yes license: CC BY-SA  

25. Conference Closing


(Needs description.) 
 recording release: yes license: CC BY  



Location
--------
Mystic Theatre


About the group
---------------