speaker-page

Luciano Ramalho

Luciano Ramalho is a Technical Principal at ThoughtWorks and the author of the bestselling book Fluent Python (O'Reilly, 2015). Since 1998 he has deployed Python on some of the largest Web sites in Brazil. His speaking record includes PyCon US, OSCON, OSCON-EU, PythonBrasil, RuPy and an ACM Webinar that was attended by more than 900 people. Ramalho is a fellow of the PSF and co-founder of the Brazilian Python Association and of Garoa Hacker Clube, the first hackerspace in Brazil.

Speaker home page

Think like a Pythonista

Fundamentals, Novice
8/13/2017 | 10:00 AM-11:00 AM | House Canary Room

Description

This talk is about some key insights that made me a better Python programmer and resulted in the success of Fluent Python.

Abstract

This talk is about some key insights that made me a better Python programmer and resulted in the success of Fluent Python.

Fluent Python was the #1 seller out of all O'Reilly books and videos in September, 2015, the first full month of sales after it was released -- and O'Reilly is the #1 seller of Python books.

Intro to Python Metaprogramming

Fundamentals, Intermediate
8/11/2017 | 1:30-5:00p | Bloomberg @ 140 New Montgomery St, SF

Description

Special methods are called to handle your objects in a variety of contexts - operator overloading, protocols, and object oriented programming.

This workshop uses TDD (Test Driven Design) to present and solve a series of problems that can be elegantly solved with special methods.

Abstract

If you look at Python itself as a framework, its core objects are the components at your service and the Data Model defines the interfaces to which you implement in your own objects. It describes common APIs for the core types in the language.

Functions, modules and classes are first class objects: they can be created, examined and modified dynamically. In particular, decorators allow customizing function and class definitions and metaclasses provide fine-grained control of class behavior. That is how frameworks from Django to Kivy do their magic.

The special methods defined in the Python Data Model are called by the interpreter to handle your objects in a variety of contexts like:

  • iteration;
  • acessing items in collections using [];
  • attribute access using obj.attr;
  • function and method invocation;
  • operator overloading;
  • string representation and formatting;
  • object creation and destruction;
  • class building;
  • managed contexts (i.e. with blocks);

This workshop uses TDD (Test Driven Design) to present and solve a series of problems that can be elegantly solved with special methods.

Modern concurrency in Python

Performant python, Experienced
8/10/2017 | 1:30p - 5:00p | Location TBD

Description

This workshop will give a high-level overview of tools like multiprocessing, concurrent.futures, the new async and await keywords, and the asyncio library - all of which enable higher performance and nonblocking operation. Attendees will work through simple yet practical examples of their use.

Abstract

Traditionally the concurrency story in Python has not been great: although threads can be trusted to improve the throughput in I/O bound programs, in the standard CPython interpreter the GIL (Global Interpreter Lock) prevents any gains with CPU-bound tasks. This started to change with the multiprocessing module introduced in Python 2.6 and 3.0, which implements nearly the same API as the threading module but using independent processes, thus sidestepping the GIL.

The concurrent.futures package added in Python 3.2 introduced the concept of a Future to represent a pending task, and the very high level Executor API, which lets you easily delegate tasks to threads or processes for asynchronous (i.e. non-blocking) execution.

Then Python 3.3 made it possible to transparently delegate processing from one coroutine to another using the new “yield from” construct. This enables asynchronous programming without callbacks or threads in user-level code, avoiding callback hell, and making multi-step asynchronous algorithms look like simple sequential code. On top of “yield from” and the Future idea, Guido van Rossum built the asyncio library, implementing a pluggable event loop and an asynchronous networking library.

This workshop will give a high-level overview of these tools, showing simple yet practical examples of their use.