EuroPython 2016

Various speakers - Lightning Talks [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] Lightning talks, presented by Harald Massa - Vitalii Vokhmin - Deploying a Hobby App in Seconds - Jernej Makovsek - Selenium Components - David Terry - Model-Based Testing - Rafael - Considerations at Scale - Team Coala - Marketing by Programmers - Facundo Batista - Python Argentina - Ania Wszeborowska - PyCon PL - Anton Coceres - PyCon DE 2016 - Shai Efrati - The Krihelinator - Lars Claussen - Live Hydrological Modelling with 3Di - Leonardo Santagada - The XONSH Shell - Fabio Pliger - How to Scale Python for Excel Users

Fabio Pliger/Endor - Welcome [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] Welcome to EuroPython 2016

Nicholas Tollervey - A Million Children (and MicroPython) [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/keynote-a-million-children-and-micropython) The BBC micro:bit is a small programmable device for children. A million of them have been handed out to the UK's 11 and 12 years olds. The Python Software Foundation was a partner in this moon-shot scheme and, thanks to the efforts of Damien George, MicroPython runs on the device. My talk will tell the story of the project, describe Python's role in it and explain how the wider Python community can become involved. It may involve demonstrations, live coding and audience participation.

Javier Arias Losada - Machine Learning for dummies with Python [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/machine-learning-for-dummies-with-python) Machine Learning is the next big thing. If you are a dummy in terms of Machine Learning, but want to get started with it... there are options. Still, thanks to the Web, Python and OpenSource libraries, we can overcome this situation and do some interesting stuff with Machine Learning. ----- Have you heard that Machine Learning is the next big thing? Are you a dummy in terms of Machine Learning, and think that is a topic for mathematicians with black-magic skills? If your response to both questions is 'Yes', we are in the same position. Still, thanks to the Web, Python and OpenSource libraries, we can overcome this situation and do some interesting stuff with Machine Learning.

Kyle Knapp - Dynamic Class Generation in Python [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/dynamic-class-generation-in-python) This talk is about dynamic class generation in python: the practice of writing code that generates classes and their functionality at runtime. It will use boto3, the AWS SDK for Python, as a basis to dive into the basics, the benefits, and the drawbacks to dynamically generating classes. ----- This talk is about the concept of dynamic class generation in python. The whole idea is writing code that generates classes and their functionality at runtime. You now may be asking yourself, “That sounds like a neat trick. Why would I ever generate my classes at runtime?” Here are a few reasons why: - It can decrease the physical size of your code. - It can improve the workflow in adding new functionality. - It can improve reliability of your code. One example where the power of this concept has really been leveraged is in boto3, the AWS SDK for Python. Dynamic class generation has allowed boto3 to become heavily data driven such that most of its classes and methods are generated based off JSON models representing aspects of an AWS service’s API. For example, to add support for a new AWS service API in boto3, just plop in a JSON file into the library with no additional Python code required. Using lessons and techniques drawn from developing boto3, this talk will dive into the following topics related to dynamic class generation: - The basics of dynamic class generation such as how to effectively dynamically generate classes. - How to overcome some of the challenges of dynamic class generation. - The tradeoffs in dynamically generating classes and discussion on when it is appropriate. By the end of this talk, the hope is that you will have a better understanding of dynamic class generation and come away with helpful ideas for your next big project.

David Arcos - Efficient Django [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/efficient-django) Does Django scale? How to manage traffic peaks? What happens when the database grows too big? How to find the bottlenecks? We will overview the basics concepts on scalability and performance, and then see some tips and tricks. These statements will be backed up with experiments and numbers, to show the timing improvements. ----- **Does Django scale?** How to manage traffic peaks? What happens when the database grows too big? How to find the bottlenecks? We will overview the basics concepts on scalability and performance, and then see some tips and tricks. These statements will be backed up with experiments and numbers, to show the timing improvements. Main topics: - System architecture - Database performance - Queues and workers - Profiling with django-debug-toolbar - Caching queries and templates - Dealing with a slow admin - Optimizing the models - Faster tests

Nicolas Lara - Python and Async programming [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/python-and-async-programming) How does the experienced python programmer fair when faced with python's "new" way of doing async programming for the first time? This talk details the different ways python provides for attacking the problem of asynchronous programming and focuses on the best practices for the future (as of python 3.4 and 3.5) ----- How does the experienced python programmer fair when faced with python's "new" way of doing async programing in for the first time? Do we all know how and when to use Futures, yield from, asyncio, coroutines, the async and await keywords, eventloops, and others? A lot has changed in recent versions of Python when it comes to async programming, concurrency, and parallelism. We still have very different ways of approaching the problem in each version, but they are finally (as of python 3.4/3.5) converging to a standard. This talk explores, from the perspective of an experienced python programmer with little to no experience in async programming, what the "one obvious way" to do async programming in Python is supposed to be. It does so but analysing examples of different categories of async problems we may want to solve and what the correct way to solve them with the latest versions of Python would be (along with the trade offs of different approaches). The examples include generic CPU-bound problems, IO-bound problems, and "both-bound" problems; along with common tasks as building a simple server, scraping, deferring a web response, and traversing graphs. When useful, I compare the solutions with the approach we would take in languages that have been design for- and are known to be good at async programming like Javascript and Go.

Lorena Mesa - Is that spam in my ham? [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/is-that-spam-in-my-ham) Beginning programmers or Python beginners may find it overwhelming to implement a machine learning algorithm. Increasingly machine learning is becoming more applicable to many areas. This talk introduces key concepts and ideas and uses Python to build a basic classifier - a common type of machine learning problem. Providing some jargon to help those that may be self-educated or currently learning ----- Supervised learning, machine learning, classifiers, big data! What in the world are all of these things? As a beginning programmer the questions described as "machine learning" questions can be mystifying at best. In this talk I will define the scope of a machine learning problem, identifying an email as ham or spam, from the perspective of a beginner (non master of all things "machine learning") and show how Python can help us simply learn how to classify a piece of email. To begin we must ask, what is spam? How do I know it "when I see it"? From previous experience of course! We will provide human labeled examples of spam to our model for it to understand the likelihood of spam or ham. This approach, using examples and data we already know to determine the most likely label for a new example, uses the Naive Bayes classifier. Our model will look at the words in the body of an email, finding the frequency of words in both spam and ham emails and the frequency of spam and ham. Once we know the prior likelihood of spam and what makes something spam, we can try applying a label to a new example. Through this exercise we will see at a basic level what types of questions machine learning asks, learn to model "learning" with Python, and understand how learning can be measured.

Antonio Spadaro - Build and control a Python-powered robot. [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/build-and-control-a-python-powered-robot) During this talk you will see how to make a robot able to recognize people with a Raspberry Pi as main board and Python as language. The talk will cover the hardware and modules, discuss briefly the alternatives, and finally show a live demo. ----- The robot uses two main modules: - **OpenCV** (_Open Source Computer Vision Library_), an open-source library that includes several hundreds of computer vision algorithms. Usage ranges from interactive art, to mines inspection, stitching maps on the web or through advanced robotics. - **gpiozero**, a simple interface to everyday GPIO components used with Raspberry Pi. The first is used to recognize the people and the object; the second to control the robot.

Rafael Monnerat - Hyperconvergence meets BigData [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/hyperconvergence-meets-bigdata) This presentation show how to deploy **[Wendelin][1]**, the free software platform for Big Data & Machine Learning, using **[SlapOS][2]** , the free software hyperconverged Operating System (hOS). Written in 100% in Python, SlapOS and Wendelin, can create a complete Big Data Infraestruture with out-of-core capabilities ready to use and operate in just few hours. [1]: http://www.wedelin.io [2]: http://community.slapos.org ----- This presentation aims to demonstrate how to use [SlapOS][1] (Hyperconverged OS) to deploy an entire Big Data Infrastrucure and show how "data life cycle" can be managed with [Wendelin][2] - covering ingestion, analysis, visualization and weaving it into an application. We'll show how Wendelin and SlapOS could handle acquisition, analysis and exploitation of data, making it a potential solution for IOT scenarios where data is available and needs some logic applied before being presented as web application, possibly on a commercial basis. The agenda of the presentation includes an introduction on SlapOS, as a tool used to deploy a wide range of different services and an introduction of Wendelin, as a tool in order to make out-of-core python applications. After a short introduction, we progress to show the steps to deploy SlapOS infrastructure and later to deploy Wendelin on the just deployed SlapOS, including an use case which shows SlapOS deploying a fluentd instance to ingest data to the Wendelin Database. To conclude, we make a live demo with an Jupiter using out-of-core python to handle wav files stored on Wendelin, and a second short demo on handle computer resources consumption data. [1]: http://community.slapos.org [2]: http://www.wendelin.io/

Liana Bakradze - Learn Python The Fun Way [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/learn-python-the-fun-way) Programming is one of the most important 21st-century skills and tons of different online and offline resources can help you to master it. On the other hand, playing games is really effective way for us to learn and it's also the most fun. But is it possible to learn real programming language like Python by playing a game? In this talk I'll show you some projects that allow you to achieve that. I also want to inspire you to help such projects and to suggest ideas how to do that. ----- Programming is one of the most important 21st-century skills. It doesn't only provide promising career opportunities but teaches how to reason logically, systematically and creatively. Code readability, rich standard library, straightforward syntax and other features make Python a great language for teaching beginners how to program. Python community is very supportive and friendly to newcomers and does awesome work to make Python available to everyone. Tons of different online and offline resources can help you to master Python programming. Problem solving is the classical way of learning how to code. But it can be boring for some people, especially for kids. On the other hand, playing games is really effective way for us to learn and it's also the most fun. You can find different games designed to teach basics of programming, but most of them use special visual environments and don't teach real text based languages. But is it possible to learn programming language like Python by playing a game? In this talk I'll show you a few projects for different age and levels that allow you to achieve that. I'll pay attention on methods that are used to teach programming. I also want to inspire you to help such projects and to suggest ideas how to do that.

Daniel Pope - Pygame Zero [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/pygame-zero) Pygame Zero is a new game engine for education, built on top of Pygame. It makes writing your first games extremely simple, while saving beginners from certain potential pitfalls. Daniel will introduce Pygame Zero, walk through creating a simple game, and discuss the background for Python in education and the design philosophy behind Pygame Zero. ----- Pygame Zero is a new game engine for education, built on top of Pygame. It makes writing your first games extremely simple, while saving beginners from certain potential pitfalls. This talk will introduce Pygame Zero, walk through creating a simple game, and discuss the background for Python in education and the design philosophy behind Pygame Zero. Pygame is a powerful set of libraries for graphics, sound, input and more. But it is just a library: each program needs to import and set up the libraries, implement a game loop and load resources among numerous other concerns. While seasoned Pythonistas have no trouble with this, teachers told us that they found it difficult to teach with Pygame. There is simply too much boilerplate involved, and getting students to reproduce the boilerplate perfectly before useful lessons can begin takes too much time out of a 40-minute lesson. Pygame Zero is simple enough that a lesson can be broken down into bitesize steps where meaningful progress can be made with just a couple of lines of code at a time.

Rachel Willmer - 20 years without a 'proper job' [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/keynote-20-years-without-a-proper-job) Have you ever wondered how you could be your own boss? or how you could make money from your side project? or build the next Facebook or Uber. To be a coder in today's world of work is to have amazing opportunities to design the business life you want. I've enjoyed the last 20 years without a 'real job', as company founder, freelancer and side-project-hacker. Now I am bootstrapping my current company to profitability. Listen to my stories and learn from my mistakes and successes. ----- Have you ever wondered how you could be your own boss? If so, then this talk is for you. Maybe you're working on a sideproject and wonder how you could make some money from it? Or maybe you have the idea for the next Facebook or Uber? To be a coder in today's world of work is to have amazing opportunities to design the business life you want. You can work remotely; you can write books, or teach, or consult, with anyone anywhere. You can have a crazy idea on Friday and have it running by Monday. Design your architecture to use cloud computing, so your tiny team can scale up your huge ideas. Or keep it small, and just earn some extra money with a Wordpress plugin, or a training course. It has been 21 years since I last had a 'real job' and a regular income. I survived creating and running a company through the madness of the dotcom years. I made money from sideprojects, that I had started just for fun and for learning. I have freelanced without needing to use an agency to find the work. And now I'm bootstrapping my current business to profitability. Listen to my stories and learn from my mistakes and successes.

Burkhard Kloss - Performant Python [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/performant-python) Python is a great language. Easy to learn, friendly to use, widely used. It is not, however, renowned for being fast. In a lot of situations that does not matter. Sometimes it really does. This talk will introduce you to some tools and techniques for making sure your Python code becomes fast enough – without turning into a maintenance nightmare. Warning: may contain small bits of other languages. ----- Python is a great language. Easy to learn, friendly to use, widely used. It is not, however, renowned for being fast. In a lot of situations that does not matter. Sometimes it really does. This talk will introduce you to some tools and techniques for making sure your Python code becomes fast enough – without turning into a maintenance nightmare. Fast code does not have to be unreadable - and when you're writing Python, it really pays of to think "pythonically". That does mean using the included batteries, and utilising the ecosystem of tools around the language, too. Warning: may contain small bits of other languages.

Cameron Macleod - Implementing a Sound Identifier in Python [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/implementing-a-sound-identifier-in-python) The talk will go over implementing a Shazam-style sound recogniser using DSP techniques and some fantastic libraries. It will cover implementation, challenges and further steps. The project is still a work in progress and the code is [available on GitHub][1]. It was inspired by the [Over-the-Air Audio Identification talk][2] at FOSDEM 2016. [1]: https://github.com/notexactlyawe/abracadabra [2]: https://fosdem.org/2016/schedule/event/audio_identification/ ----- The talk will go over the journey of implementing a Shazam-style sound recogniser using DSP techniques and some fantastic libraries. It will cover implementation, challenges and further steps. The project is still a work in progress at the time of proposal and the code is [available on GitHub][1]. It was inspired by the [Over-the-Air Audio Identification talk][2] at FOSDEM 2016. The basic structure of the project consists a classifier that fingerprints audio and stores it in a searchable form and a recogniser that fingerprints a smaller chunk of audio and then searches the stored records to find the most suitable fit for it. The recogniser will be exposed as an API to allow for different front-ends. I will aim to introduce both the field of DSP and concepts behind applications like Shazam in a simple easy-to-understand manner. The audience will not need any prior experience in anything except Python. [1]: https://github.com/notexactlyawe/abracadabra [2]: https://fosdem.org/2016/schedule/event/audio_identification/

Alain Martin - Python as the keystone of building and testing C++ applications [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/python-as-the-keystone-of-building-and-testing-c-applications) This talk explains how Ableton’s developers use Python to build and test C, C++ and Objective-C code. Our "build-system" is a collection of Python scripts that simplify our workflows, and help us write better software. The top-level scripts share a common design which makes them easy to use, maintain and extend. This talk describes the essence of that design, so you can apply it to your own project. ----- At Ableton, we make [Live][1], [Push][2] and [Link][3], unique software and hardware for music creation and performance. Live is a C++ desktop application built from a 15-year old code base. Push is an instrument embedding a multicolor display which renders a [Qt Quick][4] scene powered by [Qt][5]. Link is a technology that keeps music devices in time and is available to app developers as [LinkKit][6], an iOS SDK. "But what does all that have to do with Python?", you might ask. This talk answers that question by explaining how our developers use Python to build and test C, C++ and Objective-C source code. Based on [GYP][7], what we call "build-system" is a collection of Python scripts that simplify our workflows, and help us write better software. The three top-level scripts, "configure.py", "build.py" and "run.py", share a common design which makes them easy to use by developers, as well as easy to maintain and extend. This talk describes the essence of that design, so you can apply it to your own project. [1]: https://www.ableton.com/live/ [2]: https://www.ableton.com/push/ [3]: https://www.ableton.com/link/ [4]: https://www.qt.io/qt-quick/ [5]: http://www.qt.io/ [6]: https://ableton.github.io/linkkit/ [7]: https://gyp.gsrc.io/

Noah Kantrowitz - Behind Closed Doors: Managing Passwords in a Dangerous World [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/behind-closed-doors-managing-passwords-in-a-dangerous-world) A modern application has a lot of passwords and keys floating around. Encryptions keys, database passwords, and API credentials; often typed in to text files and forgotten. Fortunately a new wave of tools are emerging to help manage, update, and audit these secrets. Come learn how to avoid being the next TechCrunch headline. ----- Secrets come in many forms, passwords, keys, tokens. All crucial for the operation of an application, but each dangerous in its own way. In the past, many of us have pasted those secrets in to a text file and moved on, but in a world of config automation and ephemeral microservices these patterns are leaving our data at greater risk than ever before. New tools, products, and libraries are being released all the time to try to cope with this massive rise in threats, both new and old-but- ignored. This talk will cover the major types of secrets in a normal web application, how to model their security properties, what tools are best for each situation, and how to use them with major web frameworks.

David Charles - Managing Kubernetes from Python using Kube [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/managing-kubernetes-from-python-using-kube) Kubernetes is the Google Borg inspired control plane for Docker containers. It has a great API but needs a load of HTTP client code and JSON processing to use it from Python. This talk introduces Kube, a Python wrapper around the Kubernetes API that enables you to manage your Kubernetes cluster in a pythonic way while avoiding any Kubernetes API peculiarities. Programmers and operations folk who are interested in interacting with the Kubernetes API using Python. ----- ## Abstract Docker has had a transformative influence on the way we deploy software and Kubernetes, the Google Borg inspired control plane for Docker-container- hosting-clusters, is gaining similar momentum. Being able to easily interact with this technology from Python will become an increasingly important capability in many organisations. I'll discuss what the motivations behind writing Kube. We'll dive into Kube using the Python interactive interpreter, getting connected to the API, and simple viewing and label update operations. Finally I'll discuss more advanced resource management activities like Kube's 'watch' API capability. ## Objectives Attendees will learn about the key concepts in getting resource information out of their Kubernetes cluster using Kube. ## Outline 1. Setting the scene (3 minutes) 1. Other Python kubernetes wrappers (2 minutes) 1. Kubernetes concepts quick recap (5 minutes) 1. Dive into Kube in the Python interactive interpreter (10 minutes) * Outline prerequisites * The entry point - a Cluster instance * Views and Items - two important Kube concepts * Item meta data: labels and versions 1. More Kube features (5 minutes) * Creating and deleting resources * Using Kube's Watch API support * The cluster proxy attribute for when you need to get at the actual API. 1. Q&A (5 minutes)

Víctor Terrón - Kung Fu at Dawn with Itertools [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/kung-fu-at-dawn-with-itertools) The itertools module is one of the cornerstones of advanced programming in Python. This talk offers practical advice about iterator algebra that can be put into practice immediately. Discovering the itertools module means taking the veil from our eyes, and once we use functions such as repeat(), takewhile(), dropwhile() or product(), there is no return — it is impossible to come back to the world of the mere mortals, where solutions are more complex and need more memory. ----- The itertools module is one of the cornerstones of advanced programming in Python. Part of the standard library, it provides an iterator algebra that allows us to elegantly chain abstractions, enabling solutions that are both simpler and more memory efficient. The goal of this talk is to offer practical advice and clear lessons that can be immediately put into practice. Illustrating it with numerous examples, attendees will leave having assimilated at least several concepts that will improve their code undeniably and irremediably. Emphasis will be on showing specific cases where a traditional solution can be overhauled over and over with functions from the itertools module. Let’s say, for example, that we want to alternate indefinitely between two values: -1 and 1. The novice would use a variable, updating its value at each step, and the average user would maybe opt for an endless generator. Both are worthy and honorable solutions, but they pale before the mastery of the martial artist who only needs itertools.cycle(). Because that is the nature of the itertools module: once the veil falls from our eyes and we come across functions such as repeat(), takewhile(), dropwhile() or product(), there is no return. In this talk we will learn to identify when they can be used, accomplishing with a single line of code what for the mere mortals takes much more effort.

Maciej Dziergwa - The Journey from Python Developer to Python Company Owner [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/the-journey-from-python-developer-to-python-company-owner) I would like to indicate main keys to success, factors and features that help a developer to find himself on an independent career path. How to create employee-friendly work environment for Python developers? Which business model gives a chance to attract and keep more than 100 Python enthusiast? I will also gladly share some lessons learned working with dozens of clients, dozens of Python frameworks, and lots, lots of great developers. ----- Ten years ago I became a big Python fan, but at the time there were no jobs for Python developers in Poland. So, I decided to start my own Python company. Today, ten years later, this company employs more than 100 Python Developers in four cities. There are a lot of Python enthusiasts in the world, many of them more skilled than I was at that time, but clearly not anyone can become a „Python Business Developer”. In this talk I would like to indicate main keys to success, factors and features that help a developer to find himself on an independent career path. My goal is to answear these questions: How to create employee-friendly work environment for Python developers? Which business model gives a chance to attract and keep more than 100 Python enthusiast? I will also gladly share some lessons learned while working with dozens of clients, dozens of Python frameworks, and lots, lots of great developers.

Manuel Miranda - Where is the bottleneck? [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/where-is-the-bottleneck) We all know Python strength does not rely on its performance and speed when running programs. This plus the flexibility of it, can lead to build real slow and bad quality software. In this talk you will discover a set of useful tools for diagnosing where the bottleneck is in your programs along with trips for quickly realizing which is the most needed resource. ----- Have you ever felt like your software is eating your resources and you have no clue why? Have you reviewed all the lines, debugged and printed everything but you still don't know what's wrong? In this talk I will conduct a fast intro of a basic set of tools you can use to diagnose your software's performance and then we will go through a simple piece of code to show how those tools work and what you can expect from them This set of tools will include basic ones given by the OS itself like `htop`, `lsof`, `ps` and more advanced ones that let you plot the memory usage for given functions like `memory_profiler`, check CPU usage and the call graph between functions like `cprofile` and `kcachegrind` and others. By the end of the talk, you should have an idea of which are the most typical causes that can make your program slow and you will have a list of tools to search for and identify the source of the problems.

Facundo Batista - It's not magic: descriptors exposed [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/its-not-magic-descriptors-exposed) This talk shows the Python Descriptors, detailing their behaviour with a detailed practical example, so we can understand the power and flexibility they give. As a bonus track, class decorators are explained. ----- This talk presents, using a detailed practical example, the Python Descriptos. The behaviour of descriptors mechanisms is detailed, showing their power and flexibility. Finally, as a bonus track and to complete the used practical example, class descriptors are explained.

Stefan Behnel - Fast Async Code with Cython and AsyncIO [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/fast-async-code-with-cython-and-asyncio) Learn how to use the new async/await language feature to write asynchronous code in Python and [Cython][1]. See how to benefit from the excellent low-level features that Cython provides to speed up or parallelise your code, interface natively with external C/C++ code, and achieve better responsiveness and lower latency also in mostly I/O bound applications. [1]: http://cython.org/ ----- Python has recently seen a fresh development boost around asynchronous applications, triggered by the addition of the asyncio library and the new async/await language features in Python 3.5, but coming from a world of well established tools like [Twisted][2] and [Tornado][3]. The [Cython][1] compiler, which compiles Python code to C, has accompanied and influenced this development. It provides full language support for async/await under all Python versions starting from 2.6, as well as native interoperability with existing Python code and the new Python coroutines in Python 3.5. Benchmarks show that, while fully compatible, Cython compiled coroutines perform about 2-3x better than the same code executed in Python, but they additionally allow to interface natively with external C/C++ code, release the GIL, do parallel computation, and much more. All of this extends the applicable zone for asynchronous applications dramatically and can lead to better responsiveness and lower latency also for mostly I/O bound applications. This joined talk by an async I/O expert and one of the Cython core developers explains how to write code with async/await in Python and Cython, and shows how to benefit from the excellent low-level features that Cython provides on top of Python. [1]: http://cython.org/ [2]: https://twistedmatrix.com/ [3]: http://www.tornadoweb.org/

Facundo Batista - Entendiendo Unicode [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/entendiendo-unicode) Charla que explica qué es Unicode y otros conceptos relacionados para poder usar esta tecnología ----- La charla muestra de forma teórica/práctica qué son Unicode, las planillas de códigos, los caracteres, y las codificaciones, entra en detalle en las distintas codificaciones, para saber cómo usarlas, ejemplifica las reglas de oro para utilizar Unicode en nuestros programa, y termina mostrando algunas funciones útiles para el manejo de esa tecnología.

Marc-André Lemburg - So you think your Python startup is worth $10 million... [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/so-you-think-your-startup-is-worth-10-million) This talk is based on a recent consulting project the speaker ran to support the valuation of a Python startup company in the due diligence phase. By following some of the advice from this talk, you should be possible to improve the valuation of your Python startup or consulting business in preparation for investment rounds or an acquisition. ----- This talk is based on the speaker's experience running a Python focused software company for more than 15 years and a recent consulting project to support the valuation of a Python startup company in the due diligence phase. For the valuation we had to come up with metrics, a catalog of criteria analyzing risks, potential and benefits of the startup's solution, as well as an estimate for how much effort it would take to reimplement the solution from scratch. In the talk, I am going to show the metrics we used, how they can be applied to Python code, the importance of addressing risk factors, well designed code and data(base) structures. By following some of the advice from this talk, you should be able to improve the valuation of your startup or consulting business in preparation for investment rounds or an acquisition.

Vinicius Pacheco - APIs and Microservices With Go [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/apis-and-microservices-with-go) In this talk we show how the Go language helped us get a high performance in a concise and simple API. Everything will be exemplified using the backdrop of a real case of Globo.com: API registrations. We will see how we went from 200 to 19,000 records per second to the impacts of this rapid growth and the consequences of Go of use. We also show how our microservices architecture was used in the project. ----- This talk is about Go, software architecture and parallelism. How we went from legacy, complex and slow software to new, speed, resilient and maintainable software. I'll start the talk showing the problemas and the challenges that my team had received. After that, I'll show the tests, tests of performance and the options that we did considering technologies and strategies of development. The difficulties and problems also will be show. Also I talk about: - Goroutines - Resilient patterns - Go tools - Architecture - Web performance How we leave of the Java ecosystem to new free ecosystem with microservices and how Go help us.

Yury Selivanov - High Performance Networking in Python [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/high-performance-networking-in-python) The talk will cover new async/await syntax in Python, asyncio library and ecosystem around it, and ways to use them for creating high performance servers. It will explain how to build custom event loops for asyncio, with an example of using the libuv library with Cython to achieve 2-3x performance boost over vanilla asyncio. ----- The talk will start with an overview of async/await syntax introduced with PEP 492 in Python 3.5. We'll go through asynchronous context managers and iteration protocols it introduces. I'll briefly explain how the feature is implemented in CPython core. Then we'll explore asyncio design. I'll briefly cover event loop, policies, transports, protocols and streams abstractions. I'll explain that event loops are pluggable, which really makes asyncio a universal framework. We'll cover libuv - a high performance networking library that drives NodeJS. I'll highlight where it's similar to asyncio and how it's different. In the final part of the talk I'll explain how to make an asyncio compatible event loop on top of libuv. I'll showcase Cython, which is an amazing tool for tasks like this. Finally, I'll share some ideas on how we can further improve the performance of asyncio and networking in Python, and what are the challenges that we will face. **Objectives:** 1. Deeper understanding of async/await in Python and why it's important. 2. Deeper understanding of asyncio architecture and protocols. 3. How to improve asyncio performance by implementing custom event loops. 4. Show that it's easy to integrate existing complex & low level libraries with Cython. 5. Some perspective on how Python may evolve wrt networking.

Alex Willmer - CloudABI: Capability based security on Linux/Unix [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/capability-based-security-on-unix-with-cloudabi) Take POSIX, add capability-based security, then remove anything that conflicts. The result is CloudABI, available for BSD, Linux, OSX et al. A CloudABI process is incapable of any action that has a global impact It can only affect the file descriptors you provide. As a result even unknown binaries can safely be executed - without the need for containers, virtual machines, or other sandboxes. This talk will introduce CloudABI, how to use it with Python, the benefits, and the trade-offs. ----- [CloudABI](https://nuxi.nl/) is a new POSIX based computing environment that brings [capability-based security](https://en.wikipedia.org/wiki/Capability-based_security) to BSD, Linux, OSX et al. Unlike traditional Unix, if a CloudABI process goes rogue it _cannot_ execute random binaries, or read arbitrary files. This is achieved by removing `open()` & any other API able to acquire global resources. Instead a CloudABI process must be granted _capabilities_ to specific resources (e.g. directories, files, sockets) in the form of file descriptors. If a process only has a descriptor for `/var/www` then it's _incapable_ of affecting any file or folder outside that directory. This talk will - Review the security & reusability problems of Linux & Unix processes - Introduce capability-based security - Summarize the design of CloudABI - its benefits & trade-offs - Demonstrate how to write Python software for CloudABI & run it - Point out the pitfalls & gotchas to be aware of - Discuss the current & future status of CloudABI CloudABI began life on FreeBSD. It also runs DragonFly BSD, NetBSD, PC-BSD, Arch Linux, Debian, Ubuntu, & OS X. The API & ABI are kernel agnostic - a CloudABI binary can run on any supported kernel. The design is evolved from [Capsicum](https://www.cl.cam.ac.uk/research/security/capsicum/), a library that allows processes to drop access to undesired syscalls at runtime. CloudABI applies this at build time to make testing & lock- down easier.

Daniele Procida - Minds, machines and Python [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/minds-machines-and-python) Are we looking in the wrong direction for artificial intelligence and machine learning? I'll discuss an older but perhaps more satisfying approach, that has been neglected in recent years. It begins with questions in logic and language, and can be explored using easy techniques. I'll use simple Python programs to explore three key notions in this AI research: **loops**, **self-reference** and **tangled hierarchies**, themselves directly reflected in important programming concepts. ----- In recent years, we've seen interesting and spectacular successes in artificial intelligence and machine learning, made possible by leaps in computing power and techniques able to harvest vast quantities of data. The results are uncanny. We see them everywhere, from the personal assistants built into smartphones to the neural networks that do an astounding job of recognising images. However, they're also susceptible to the criticism that they represent not intelligence but a mere simulation of it, and that producing a convincing simulacrum has become more important than a genuine search for intelligence or learning. At the same time, another, perhaps deeper, approach has become neglected in recent decades, along with the questions it asks about the nature of mind, intelligence and learning. This approach begins with fundamental questions in logic and language, and can be explored using some of the simplest programming techniques. In this talk, I'll use simple Python programs to explore three key notions in this strand of artificial intelligence research: *loops*, *self-reference* and *tangled hierarchies*. The way these concepts directly reflect important concepts in programming suggests that for the programmer, this approach could be more interesting and satisfying, and simply more **fun,** than using huge ontologies and big data to create mere simulacra of intelligence. The examples I use will be concrete and easy to understand, even for novice programmers.

Radomir Dopieralski - Making robots walk with Python [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/making-robots-walk-with-python) You will see several different walking robots controlled with Python in different ways, and learn how they were built and programmed. ----- Making a robot walk is not easy, especially when all it has for brains is a small microcontroller which you have to program in C. During this talk you will see different ways in which such a robot can be controlled in Python, either by using remote control, with the Python program running on a stationary computer, by putting a small computer, such as a Raspberry Pi on it, or by programming it with Micropython, a version of the Python language designed for microcontrollers. I will also explain the basic problems with walking robots and how Python can be used to overcome them. Finally, I will show some of the robots I have built.

Shahriar Tajbakhsh - Go for Python Programmers [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/go-for-python-programmers) A side-by-side walkthrough of basic Go history, syntax, semantics and tools compared to Python. ----- There's been quite a bit of hype around Go for some time. In particular within the Python community, we've seen some engineers moving their stack from Python to Go or starting their new project in Go. This talk is **not** about whether you should move from Python to Go. Instead, this talk is for those who've been hearing all about all the hype but haven't yet had a chance to take a proper look at Go. We'll first _very_ briefly look at Go and Python's history. Then we'll go through a high-level side-by-side walkthrough of basic Go syntax and semantics compared to Python. Finally, we'll have a brief look at a subset of the ecosystem and tools available to Go and Python programmers for certain tasks such as testing, code formatting, documentation generation etc. By the end, you will not be a Go programmer but you'll have a high- level feel for how the Go language operates.

Stephane Wirtel - Exploring our Python Interpreter [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/exploring-our-python-interpreter) During the last CPython sprints at PyCon US (Montreal), I started to contribute to the CPython project and I wanted to understand the beast. In this case, there is only one solution, trace the code from the beginning. From the command line to the interpreter, we will take part to an adventure. The idea behind is just to show how CPython works for a new contributor. ----- During my last CPython sprint, I started to contribute to the CPython code and I wanted to understand the beast. In this case, there is only one solution, trace the code from the beginning. From the command line to the interpreter, we will take part to an adventure * Overview of the structure of the project and the directories. * From the Py_Main function to the interpreter. * The used technics for the Lexer, Parser and the generation of the AST and of course of the Bytecodes. * We will see some bytecodes with the dis module. * How does VM works, it's a stack machine. * The interpreter and its main loop of the Virtual Machine. The idea behind is just to show how CPython works for a new contributor to CPython. From the command line, we will learn that Python is a library and that we can embed it in a C project. In fact we will see the Py_Main function to the ceval.c file of the interpreter. But there is no magic in the CPython code, we will travel in the lexer and the parser of CPython, and why not, by the AST for one Python expression. After the AST, we will visit the Compiler and the Bytecodes for the interpreter. Of course, we will learn there is the peepholer where some basic instructions are optimised by the this component. And of course, the interpreter, this virtual machine is really interesting for the newbiew, because it's a big stack where the bytecodes are executed one by one on the stack and the ceval.c file.

Juan Manuel Santos - Salting things up in the DevOps' World: things just got real [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/salting-things-up-in-the-devops-world-things-just-got-real) SaltStack is a thriving configuration management system written in Python that leverages YAML and Jinja2 which, by now, probably needs no introduction. This talk will explore Salt beyond the minimum required setup, targeting developers/sysadmins already using Salt, and those considering making the switch from other systems but wishing to dive deeper first. Attendees should be familiar with configuration management systems and practices, and comfortable using and reading YAML and Jinja syntax. ----- There is much more to Salt than the basics. This talk will go beyond the minimum required setup and will take a look at Salt under the hood, which will appeal not only to system administrators, but will also be more interesting to developers and to the DevOps community in general as the talk progresses. Topics include: * Introduction and basics review (master/minions, matching, grains, pillar) * Salt Mine * Syndic node * State modules vs. runner modules * The Reactor * The Event System * Salt Beacons * Salt API Attendees should be familiar with configuration management systems and practices, and also feel comfortable using and reading YAML and Jinja syntax. This talk is targeted to developers or sysadmins already using Salt, and to those who are considering switching to it from other systems but wish to dive deeper before making that decision. After the talk, attendees will have a better grasp of the more advanced possibilities that Salt brings, and be ready to apply them to their use cases.

Zuria Bauer/Daniel Domene López - How to improve your diet and save money with Python [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/how-to-improve-your-diet-and-save-money-with-python) Optimization in Python (also known as mathematical programming) can be performed by minimization (or maximization) of an objective function within a model that can include discrete variables subject to a set of constrains. At this talk, chemical engineering students of the University of Alicante will introduce the audience to the possibilities of optimization, presenting Pyomo and showing real world examples such as how to improve your diet and save money at fast food restaurants. ----- Process optimization in industry has become essential in order to maximize the resources available and reduce energy consumption. Optimization problems become interesting when dealing with restrictions (linear or nonlinear) and integer variables (modeling the discrete decisions). Python ecosystem presents different libraries to solve optimization problems, some of them are CVXOpt, CVXPy, PulP, OpenOpt, or Pyomo. Among them, Pyomo results interesting because: - It can be used for Mathematical modeling in Python similarly to AMPL (and GAMS) - It communicates with the main solvers used in this field such as GLPK, Gurobi, CPLEX, CBC and PICO - It's free and open source Python library (BSD license), being developed by Sandia National Laboratories, USA. - It supports Python 3 and it is easy to install. The talk will be divided in three parts: 1. _Introduction to Mathematical Programming/Optimization (15 min):_ visual introduction to optimization concepts including restrictions and non linearties (linear Programming, Nonlinear Programming, ILP, MIP, MINLP). 2. _Introduction to the Pyomo sintax and a quick note for the installation (20 min):_ showing how to improve their diet and save money when ordering food in fast food restaurants. 3. _Optimization problems in engineering (10 min):_ showing more advanced optimization examples that include decision variables.

Theo Crevon - Automate, contribute, repeat. [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/automate-contribute-repeat) At Ableton we love music and we love open-source. Ansible is an amazing tool which allows us to free more time for music by automating boring and repetitive tasks, and to contribute back to the open-source community with ease. Here's an opportunity to share our love for it, our experience with it, and our contributions to it with you. ----- Computers are never as convenient as when they work for us. If you agree with this motto, then Ansible, a deployment and automation tool written in Python, might come in handy. At Ableton, Ansible is involved in every aspect of deployment and automation. From local machine setup, to vm creation and deployment in our self-hosted datacenter, to our services in the immensity of the cloud. Because it is dead simple to use, can deal with any number of hosts in parallel and has robust compatibility with Unix as well as Windows systems, you will probably never have to write a shell script again. Because it is written in Python and exposes a clean, extensible and easy to adapt design and architecture; contributing features to the project and fixing the bugs you might encounter during the journey is extremely easy. At Ableton we love music and we love open-source. Ansible is an amazing tool which allows us to free more time for music by automating boring and repetitive tasks, and to contribute back to the open-source community with ease. Here's an opportunity to share our love for it, our experience with it, and our contributions to it with you. Automate, contribute, repeat.

Scott Triglia - Protect your users with Circuit Breakers [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/protect-your-users-with-circuit-breakers) Failures are the bane of scaling a modern web service and can cause serious pain for end users! Lucky for us, there are techniques that can help protect your product and handle failures in subsystems gracefully. This talk will dive into one of these in depth, the Circuit Breaker pattern, and explore the options it gives us for keeping all our users safe. We will be focusing on several real-world problems and options for how to implement your circuit breaker setup in nice, readable python code. ----- The inevitability of failures is the bane of scaling any modern web service and can cause serious pain for end users! Lucky for us, there are techniques that can help protect your product handle failures in subsystems gracefully. This talk will dive into one of these in depth, the Circuit Breaker pattern, and explore the options it gives us for keeping our users safe. We will be focusing on several real-world problems and how they can be addressed by circuit breakers. You should expect to leave the talk with details on simple circuit breakers as well as understanding how they can be adapted for more complex situations. We’ll also discuss some options for how to implement your circuit breaker in readable python. **Contrived FAQ time!** **I don’t know what Circuit Breakers are, should I come?** Definitely! We’re going to start from scratch and work our way up. Only requirement is basic familiarity with backend services receiving and making HTTP requests. **I totally know what Circuit Breakers are, should I come?** Definitely! After the intro, the main meat of the talk will be working through a series of more advanced situations and talking about how we can alter the basic circuit breaker setup to address them. **I want real-world advice, not made up hypotheticals!** Well that’s not really a question, but you’ll be happy to know that the examples we’ll discuss come straight from my experience at Yelp. They should be very realistic and broadly applicable.

Ilia Kurenkov - re-Discovering Python's Regular Expressions [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/rediscovering-pythons-regular-expressions) As Armin Ronacher pointed out in a recent blog post, there is more to Python's regular expression module than meets the eye. His post made me wonder what other “hidden gems” are stashed away in Python’s `re`. In the talk I share what I’ve learned about the inner workings of this extremely popular and heavily used module. ----- Anyone who has used Python to search text for substring patterns has at least heard of the regular expression module. Many of us use it extensively for parsers and lexers, extracting information . And yet we know surprisingly little about its inner workings, as Armin Ronacher demonstrated in his recent blog post, “Python's Hidden Regular Expression Gems”. Inspired by this, I want to dive deeper into Python’s `re` module and share what I find with folks at EuroPython. My goal is that at the end of the day most of us walk away from this talk with a better understanding of this extremely useful module. Here are a few examples of the kinds of things I would like to cover: - A clear presentation of `re`’s overall structure. - What actually happens behind the scenes when you “compile” a regular expression with `re.compile`? - What are the speed implications of using a callable as the replacement argument to `re.sub`? - re.MatchObject interface: `group` vs. `groups` vs `groupdict` To keep the talk entertaining as well as educational I plan to pepper it with whatever interesting and/or funny trivia I find about the module’s history and structure. Prerequisites: If you've ever used the `re` module, you should be fine :)

Honza Král - Designing a Pythonic Interface [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/designing-a-pythonic-interface) When designing an abstraction for a complex system (an ORM-like library in our case) you face a lot of design decisions and challenges. This talk details how we chose to tackle those when designing elasticsearch-dsl. ----- The json query language for elasticsearch, as well as its other APIs, can be very daunting to new users and can be a bit cumbersome when working with python. That is why we created elasticsearch-dsl - a sort of ORM for elasticsearch. We will go through the design philosophy and obstacles found during the development - trying to make a more pythonic interface for elasticsearch while maintaining access to all of the features of the underlying query language. The focus of the talk is more on the library and interface design than on elasticsearch and its query language itself, that is used only to demonstrate the principles.

vincent warmerdam - The Joy of Simulation: for Fun and Profit [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/the-joy-of-simulation-for-fun-and-profit) In this talk discusses some joyful exercises in simulation. I'll demonstrate it's usefulness but moreover I'll discuss the sheer joy. I'll discuss how to generate song lyrics, I'll discuss how to get better at casino games, how to avoid math, how to play monopoly or even how to invest in lego minifigures. No maths required; just a random number generator. ----- In this talk discusses some joyful exercises in simulation. I'll demonstrate it's usefulness but moreover I'll discuss the sheer joy you can experience. I'll go over the following points (the short list): - I'll show how you can avoid math by simulating; I'll calculate the probability that two people in the live room have the same birthday. - I'll show how simulation can help you get better at many games. I'll start with simple card games and with the game of roulette. Most prominently I'll discuss how to determine the value of buying an asset in the game of monopoly (See blogpost: http://koaning.io/monopoly- simulations.html). - I'll demonstrate how you can simulate Red Hot Chilli Pepper lyrics. Or any other band. Or legalese. - I'll demonstrate the results of a scraping exercise which helped me to determine the value of investing in Lego Minifigures (See blogpost: http://koaning.io/lego-minifigs-stochastics-profit.html). Depending on the level of the audience I might also discuss how biased simulation can help you solve optimisation problems or even introduce bayesian statistics via sampling. I'll gladly leave this decision to the EuroPython committee.

Sebastian Witowski - Writing faster Python [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/writing-faster-python) Presentation on how you can write faster Python in your daily work. I will briefly explain ways of profiling the code, discuss different code structures and show how they can be improved. You will see what is the fastest way to remove duplicates from a list, what is faster than a _for_ loop or how “asking for permission” is slower than “begging for forgiveness”. ----- Did you know that Python preallocates integers from -5 to 257 ? Reusing them 1000 times, instead of allocating memory for a bigger integer, can save you a couple of milliseconds of code’s execution time. If you want to learn more about this kind of optimizations then, … well, probably this presentation is not for you :) Instead of going into such small details, I will talk about more _"sane"_ ideas for writing faster code. After a very brief overview of how to optimize Python code (rule 1: don’t do this, rule 2: don’t do this yet, rule 3: ok, but what if I really want to do this ?), I will show simple and fast ways of measuring the execution time and finally, discuss examples of how some code structures could be improved. You will see: - What is the fastest way of removing duplicates from a list - How much faster your code is when you reuse the built-in functions instead of trying to reinvent the wheel - What is faster than the good ol’ _for_ loop - If the lookup is faster in a list or a set (and when it makes sense to use each) - How the “It's better to beg for forgiveness than to ask for permission” rule works in practice I will NOT go into details of _"serious"_ optimization, like using different Python implementation or rewriting critical code in C, etc.

Mike Müller - Conda - Easier Installs and Simpler Builds [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/conda-easier-installs-and-simpler-builds) Learn about `conda`, the package installer from the scientific community. It offers very interesting features that can improve your installation experience considerably. The talk gives an overview of the basic usage of `conda`. It covers the topics installation and building of packages. `conda` can be combined with `pip` to use all PyPi packages. Its cross-platform and multi-languages features combined with power environments can help to improve your productivity. ----- The BSD license `conda` is a package installer for Python and other languages. While it originates form the scientific Python community, it can be really useful for all Python programmers. Installation of Python packages has become much simpler over the last years. The use of `pip` and `virtualenv` simplify the installation of Python packages a lot. However, they are specific to Python. The Python-agnostic `conda` has advantages for packages with C or Fortran extension that are very common for scientific libraries. `conda` is cross-platform. According to different statistics, the most Python users work on Windows. Often is especially complicate to get extensions with many dependencies installer on this platform. `conda` facilities the installation for Windows considerably. This talk introduces the basic usage of `conda` to install packages. This includes the basic commands for searching and installing of packages. Furthermore, the talk demonstrates the creation of environments for different Python versions and combinations of packages. The building of a packages is simple. The talk shows how to build recipes that contain declarations of dependencies . `conda` can work together with `pip`. This allows to use all packages from the Python Package Index ( PyPI). The talk explains the concept of channels that allow to get packages from different sources.

Fabio Pliger - Recruiting session [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/recruiting-session) The recruiting sponsors will present their companies and their job offers in short talks.

Dougal Matthews - Effective Code Review [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/effective-code-review) Developers usually state that finding defects is the primary motivation for doing code reviews. However, research has shown that the main benefits of code reviews are; knowledge transfer, team awareness and finding alternative solutions. Code reviews when done well are more than just finding defects; it should be a discussion and conversation with other developers about finding the best solutions. We will talk about re-framing code review to encourage open discussions. ----- This talk is for everyone that is already involved in regular code review and those hoping to start. I will talk through the code review process with the aim of making it a better and more useful experience for both the authors and the reviewers. The talk will follow the following rough outline: - Introduction - Why do code reviews - What are we aiming to get out of it - Submitting code for review - How can you help reviewers? - What should you avoid doing? - Removing ownership of the code - Reviewing code - How should you give feedback? - What should you look for? - How can you encourage people to review more? - How to avoid and remove bike-shedding - Code review tools and how they impact on the process. - Wrap up and conclusion

Ankit Bahuguna - Query Embeddings: Web Scale Search powered by Deep Learning and Python [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/query-embeddings) Query Embeddings is an unsupervised deep learning based system, built using Python and open source libraries (Annoy, keyvi etc.) which recognizes similarity between queries and their vector representations, for a web scale search engine integrated within Cliqz browser [https://cliqz.com/en]. It improves recall for previously unseen queries and is one of the many key components of our search stack. The framework be utilized by other low latency systems involving vector representations. ----- A web search engine allows a user to type few words of query and it presents list of potential relevant results within fraction of a second. Traditionally, keywords in the user query were fuzzy-matched in realtime with the keywords within different pages of the index and they didn't really focus on understanding meaning of query. Recently, Deep Learning + NLP techniques try to _represent sentences or documents as fixed dimensional vectors in high dimensional space_. These special vectors inherit semantics of the document. Query embeddings is an unsupervised deep learning based system, built using Python, Word2Vec, Annoy and Keyvi (https://github.com/cliqz- oss/keyvi) which recognizes similarity between queries and their vectors for a web scale search engine within Cliqz browser. (https://cliqz.com/en) ![][1] The goal is to describe how query embeddings contribute to our existing python search stack at scale and latency issues prevailing in real time search system. Also is a preview of separate vector index for queries, utilized by retrieval system at runtime via ANNs to get closest queries to user query, which is one of the many key components of our search stack. ![][2] Prerequisites: Basic experience in NLP, ML, Deep Learning, Web search and Vector Algebra. Libraries: Annoy. [1]: https://sites.google.com/site/netankit/1.png [2]: https://sites.google.com/site/netankit/3.png

Marko Samastur - Publish your code so others can use it in 5 easy steps [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/publish-your-code-so-others-can-use-it-in-5-easy-steps) As developers we all love well-documented, well-tested packages. If we do the same for our code it is easier for others to re-use our hard work, and maybe even contribute. We will take a quick look on how to do this using popular tools and only a small investment of time. With Github and some simple tools, setting up a well-groomed package doesn't have to be difficult. ----- Every Python open-source developer wants their software to be used. As developers, we trust software that is tested and well-documented. In this talk we'll go through 5 steps for how to do this for your own packages. We will take a quick look on how to do this using popular tools and small investment of time: - Write a setup.py script for a pure Python package - Set up py.test, tox and coverage to test our package with multiple versions of Python - Configure Github to use Travis CI & coveralls.io to automatically test our package every time we commit - Register and publish our package to PyPI - Setup our documentation on ReadTheDocs

Alexander Hendorf - Game Theory to the Rescue When Hard Decisions Are to Be Made [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/game-theory-to-the-rescue-when-hard-decisions-are-to-be-made) Sometimes it's hard to decide when a something is really done or cannot be improved further. **Game theory** can help you to make complicated decisions whenever you encounter flow problems. ----- Game theory is "the study of mathematical models of conflict and cooperation between intelligent rational decision-makers." In our use case we had to match data for accounting: - the data was not always clean but we had some extra tools at hand and a complex system to make good guesses. Nevertheless it was hard to decide when to give up, some records were just not processable. Finally we used Game theory to make the decision. https://en.wikipedia.org/wiki/Game_theory

Juan Luis Cano - Per Python ad Astra [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/per-python-ad-astra) In the intersection of mechanics, mathematics and "cool stuff that travels through space" lies Astrodynamics, a beautiful branch of physics that studies the motion of spacecraft. In this talk we will describe poliastro, a pure Python library we can use to compute orbital maneuvers, plot trajectories and much more. The role of JIT compiling (using numba) to drop the previously used FORTRAN algorithms will also be discussed, as well as the importance of open source in scientific discoveries. ----- In the intersection of mechanics, mathematics and "cool stuff that travels through space" lies Astrodynamics, a beautiful branch of physics that studies the motion of spacecraft. Rocket launches have never been so popular thanks to companies like Space X, more and more investors pay attention to aerospace startups and amazing missions explore our planet and our Solar System every day. In this talk we will describe poliastro, a pure Python library we can use to compute orbital maneuvers, plot trajectories and much more. The role of JIT compiling (using numba) to drop the previously used FORTRAN algorithms will also be discussed, as well as the importance of open source in scientific discoveries.

Christian Trebing - Get in control of your workflows with Airflow [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/get-in-control-of-your-workflows-with-airflow) Airflow (https://github.com/airbnb/airflow) is an open source Python package from Airbnb to control your workflows. This talk will explain the concepts behind Airflow, demonstrating how to define your own workflows in Python code and how to extend the functionality with new task operators and UI blueprints by developing your own plugins. You'll also get to hear about our experiences at Blue Yonder, using this tool in real-world scenarios. ----- Whenever you work with data, sooner or later you stumble across the definition of your workflows. At what point should you process your customer's data? What subsequent steps are necessary? And what went wrong with your data processing last Saturday night? At Blue Yonder we use Airflow (https://github.com/airbnb/airflow), an open source Python package from Airbnb to solve these problems. It can be extended with new functionality by developing plugins in Python, without the need to fork the repo. With Airflow, we define workflows as directed acyclic graphs and get a shiny UI for free. Airflow comes with some task operators which can be used out of the box to complete certain tasks. For more specific cases, tasks can be developed by the end user. Best of all: even the configuration is done completely in Python! This talk will explain the concepts behind Airflow, demonstrating how to define your own workflows in Python code and how to extend the functionality with new task operators and UI blueprints. You'll also get to hear about our experiences using this tool in real-world scenarios.

Ricardo Bánffy - Lessons Learned after 190 Million Lessons Served [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/lessons-learned-after-190-million-lessons-served) What we learned along the way - processes, organization, technology and people - from 0 to 11 million students, 40 thousand courses and 20 thousand teachers.

Roberto De Ioris - Modern OpenGL with Python [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/modern-opengl-with-python) The OpenGL api is one of the oldest (and most used) graphics library in both the gaming and simulations world. In latest years the api has been extremely re-designed to support modern hardware features available in GPUs. Can we build realtime graphics application with Python using OpenGL ? Well, obviously Yes ! ----- The talk will introduce how 2D and 3D graphics works, which math is required for mastering them and why strong hardware cooperation and heavy optimizations have been required since the very beginning of gaming development history. Once the theory is "almost" clear, we can start talking about OpenGL, which problems tries to solve and how it evolved in more than 20 years. The last (and the biggest) part of the talk will show how to interface Python with OpenGL, how to draw simple 2D sprites and how to load and show 3D models using simple lighting models. Warning: OpenGL shaders (the custom code you upload in the GPU) are written in GLSL, a pseudo-c dialect, so expect a bit of lower-level programming

Naomi Ceder - PSF Meeting [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/psf-meeting-2016) EuroPython Meeting of the Python Software Foundation Members and non-members are invited to this EuroPython meeting of the PSF! Please join us for some updates from the PSF board.

Andrew Svetlov - Introduction to aiohttp [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/introduction-to-aiohttp) aiohttp is asynchronous HTTP client and server library built on top of asyncio. The intro describes basic programming patterns for both client and server API as well as more advanced techniques. The main target of the talk is displaying an alternative to people who want to avoid classic WSGI frameworks (Django/Flask/Pyramid etc) limitations but found Twisted and Tornado too cumbersome. ----- aiohttp is asynchronous HTTP client and server library built on top of asyncio. The library allows to write user friendly code which looks like well-known linear one (requests library for client and Django/Flask/Pyramid for server) but utilizes the power of non-blocking sockets and supports websockets natively. The intro describes basic programming patterns for both client and server API as well as more advanced techniques. Tips and tricks for writing asyncio-based code are included as well. The main target of the talk is displaying an alternative to people who want to avoid classic WSGI frameworks (Django/Flask/Pyramid etc) limitations but found Twisted and Tornado too cumbersome. Dive into aiohttp usage with the library author.

Sebastian Neubauer - Infrastructure as Code: "pip install" your environment [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/infrastructure-as-code-pip-install-your-environment) In this talk I will show how to build your own infrastructure- as-a-service on the example of "Postgraas", an open source postgres- as-a-service I wrote in python just for fun. With a simple curl request you can get your very own database, just like RDS on AWS. You will learn how easy it is to create such a remarkably useful service with hardly three hundred lines of flask, docker and some glue-code, a project for a rainy Sunday. ----- Continuous Delivery, DevOps, Lean - all those movements have one thing in common: extending the process of software development along the whole value stream, ultimately to the customer. This simple requirement causes surprising serious difficulties on traditional operations workflows. All of a sudden, a single manual ticket to the operations team is a critical blocker in the delivery process. Therefore all parts of the infrastructure, storage, databases, identities, compute resources must be provided as a self service for the developers in order to be able to achieve this goal. What one may call "the cloud" (including self hosted ones like open stack) is such a successful model not least because they offer exactly this "ticket- less" self-service. But why should we wait for "the cloud" to offer what we really need? We are python developers, we are hackers! In this talk I will show how to build your own infrastructure- as-a-service on the example of "Postgraas", an open source postgres- as-a-service I wrote in python just for fun. With a simple curl request you can get your very own database, just like RDS on AWS. You will learn how easy it is to create such a remarkably useful service with hardly three hundred lines of flask, docker and some glue-code, a project for a rainy Sunday. After the talk you will know how to amaze your colleagues by eliminating an annoying ticket or manual workflow with a simple flask app and some creativity.

Miguel Cabrera - Things I wish I knew before starting using Python for Data Processing [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/things-i-wish-i-knew-before-starting-using-python-for-data-processing) In recent years one of the ways people get introduced into Python is through its scientific stack. Although this is not bad, it may lead to learn solely one aspect of the language, while overlooking other idioms and functionality included in Python as well as some basic software development good practices. I will share some useful tricks, tools and techniques and software design and development principles that I find beneficial when working on a data processing / science project. ----- In recent years of the ways people get introduced into Python is through its scientific stack. Most people that learned Python this way are not trained software developers and many times it is the first contact with a programming language. Although this is not bad, it may lead to learn solely one aspect of the language while overlooking other idioms, standard and common libraries included in Python as well as some basic software development good practices. This may become a problem when a data science project is moved from an experimentation phase to an integration with technical environment. In this talk I share some useful tricks, tools and techniques and as well as some software design and development principles that I find beneficial when working on a data processing / science project. The talk is divided into two parts, one is Python centered, where I will talk about some powerful Python construct that are useful in data processing tasks. This include some parts collections module, generators and iterators among others. The other I will describe some general software development concepts including SOLID, DRY, and KISS that are important to understand the rationale behind software design decisions.

Kali Kaneko - Against the silos: usable encrypted email & the quest for privacy-aware services [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/against-the-silos-usable-encrypted-email-the-quest-for-privacy-aware-services) At the LEAP Encryption Access Project we aim to make secure communications both easy to use and easy to provide. We bring some tales (and some, hopefully, tools) from the quest for user-friendly crypto software. How to make people love the email experience in the 21st century, without risking their privacy. How to encrypt data locally, sync it to servers that you can lose, and still be sexy. ----- Technologies that allow for privacy in the communications, allowing the escape from the pervasive massive surveillance, have been there for some years now, but yet its use by the general public is far from widespread. The challenge, in our view, can be defined by one of making usable crypto. Usable for the end user, usable for the sysadmin and for the fellow application developer. In the quest for massive adoption of encryption technologies, we've been forging several python packages to solve different problems, always standing in the shoulders of giants. We bring some tales from the trenches to share, from our humble experience trying to deploy clients and servers to provide Secured Encrypted Internet Tunnels and Encrypted Email. This includes interesting challenges dealing with key management, automatic and secure software updates, and processing of email while using stock cloud providers, while still being resistant to hostile environments. We'll show a webmail email user agent based on this architecture, a promising future for decentralization and privacy. We'll also talk about how to store locally encrypted data, and will present Soledad (Synchronization of Locally Encrypted Data Across Devices). Soledad is a library with server and client components that allows the development of different applications based on client-side, end-to-end and cloud-syncable encryption of private data. We'll play with some toy apps to showcase its features and potential.

Erik Näslund - Building a reasonably popular web application for the first time. [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/building-a-reasonably-popular-web-application-for-the-first-time) These are the lessons learned when scaling a SaaS web application which grew much faster than any one us could have ever expected. - Log and monitor from day one. - Things will fail, be sure you know when they do. - Choose components which allow language interoperability. - Horizontally scalable everything. - Plan for database downtime. - Have a way to share settings between backend and frontend. - Have a way to enter maintenance mode. - And more... ----- My name is Erik Näslund - I’m the co-founder and Head of Engineering at Hotjar. I'd love to share the lessons learned when scaling a SaaS web application which grew much faster than any one us could have ever expected. Words like “big” and “popular” carry very little meaning, so let me define how big Hotjar is right now using some numbers. We onboard about 500 new users on a daily basis. We process around 250 000 API requests every minute. Our CDN delivers about 10 TB of data per day. We have roughly 3 TB of data in our primary data store (PostgreSQL), another 1 TB in our Elasticsearch cluster, and a LOT more on Amazon S3. These are the key things we wish we knew when we started. They would have made our life so much easier! - Log and monitor from day one. - Have a way to profile your API calls. - Things will fail, be sure you know when they do. - Have a way to keep secrets. - Everything needs a limit (even if it's really big). - Be wary of hitting data type limits. - Don't get too attached to a framework. - Choose components which allow language interoperability. - Horizontally scalable everything. - Plan for database downtime. - Features are a great way to test things out before launching them to the public. - Have a way to share settings between back end and front end. - Have a way to enter maintenance mode. - Require different quality of code for different parts of your application.

Anders Hammarquist - Metaclasses for fun and profit: Making a declarative GUI implementation [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/metaclasses-for-fun-and-profit-making-a-declarative-gui-implementation) When standard Python syntax doesn't cut it, apply metaclasses to make it do what you want. Here I present our metaclass-based implementation of a declarative GUI layout syntax to inspire ideas for what to do when your goals don't fit the Python syntax. ----- When overhauling the user interface of Autolabel's labeling printers, we wanted a clean way to describe the layout of the settings widgets. The structure we came up with was a declarative class layout that leverages Python's metaclass concept to build the underlying GTK widget structure. I will present the implementation to hopefully inspire you to apply metaclass techniques to problems that standard Python syntax can't quite solve. If that fails, you will at least have a way to declaratively construct GTK GUIs. A short, non-exaustive, summary of concepts I will mention includes metaclasses (obviously), class hierarchies, method resolution order, super(), and anecdotes of dealing with GTK. You may find some similarities with my talk on Python as a domain specific language at Europython 2006 http://indico.cern.ch/event/44/session/41/contribution/35 Slides are available at https://www2.openend.se/~iko/ep2016 Example code on Bitbucket https://bitbucket.org/iko/ep2016-declarative-gui/

Larry Hastings - The Gilectomy [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/the-gilectomy) CPython's GIL means your Python code can only run on one CPU core at a time. Can we remove it? Yes, we can... in fact we already have! But is it worth the cost? ----- CPython's "Global Interpreter Lock", or "GIL", was added in 1992. It was an excellent design decision. But 24 years is a long time--today it prevents Python from capitalizing on multiple CPUs. Many people want us to remove the GIL. It turns out, removing the GIL isn't actually that hard. In fact, I already removed it, in my experimental "gilectomy" branch. But the GIL is one reason CPython is so fast! The "gilectomy" makes CPython shockingly slow. This talk will discuss the history of the GIL, how the GIL helps make CPython fast, how the "gilectomy" removed the GIL, and some ways we might be able to make the "gilectomy" version fast enough to be useful.

Victor Stinner/Larry Hastings/Christian Heimes/Yury Selivanov - Core Developers' Panel [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] Q&A session with Python core developers

Jameson Rollins - LIGO: The Dawn of Gravitational Wave Astronomy [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/keynote-ligo) Scientists have been searching for the elusive gravitational wave for more than half a century. Hear how they finally found them, and the role that Python played in the discovery. ----- Scientists have been searching for the elusive gravitational wave for more than half a century. On September 14, 2015, the Laser Interferometer Gravitational-wave Observatory (LIGO) finally observed the gravitational wave signature from the merger of two black holes. This detection marks the dawn of a new age of _gravitational wave astronomy_, where we routinely hear the sounds emanating from deep within the most energetic events in the Universe. This talk will cover the events leading up to one of the most important discoveries of the last century, and the myriad of ways in which Python enabled the effort.

Alexys Jacob - Using Service Discovery to build dynamic python applications [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/service-discovery-for-dynamic-python-applications) Let's compare the usage of three major **service discovery** technologies to build a dynamic and distributed python application ! This talk will be about **consul**, **etcd** and **zookeeper** and their python bindings and will feature code along with a live demo. ----- This talk will **showcase and compare** three Service Discovery technologies and their usage to **build a dynamic and distributed python application** : - consul - etcd - zookeeper After a short introduction to service discovery, we will **iterate and compare** how we can address the concrete and somewhat complex design of our python application using each technology. We'll then be able to discuss their strengths, weaknesses and python bindings and finally showcase the application in a demo. All the source code will of course be made available for the audience to benefit and start from for their own use !

Victor Stinner - FAT Python: a new static optimizer for Python 3.6 [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/fat-python-a-new-static-optimizer-for-python-36) The Python language is hard to optimize. Let's see how guards checked at runtime allows to implement new optimizations without breaking the Python semantic. ----- (Almost) everything in Python is mutable which makes Python a language very difficult to optimize. Most optimizations rely on assumptions, for example that builtin functions are not replaced. Optimizing Python requires a trigger to disable optimization when an assumption is no more true. FAT Python exactly does that with guards checked at runtime. For example, an optimization relying on the builtin len() function is disabled when the function is replaced. Guards allows to implement various optimizations. Examples: loop unrolling (duplicate the loop body), constant folding (propagates constants), copy builtins to constants, remove unused local variables, etc. FAT Python implements guards and an optimizer rewriting the Abstract Syntax Tree (AST). The optimizer is implemented in Python so it's easy to enhance it and implement new optimizations. FAT Python uses a static optimizer, it is less powerful than a JIT compiler like PyPy with tracing, but it was written to be integrated into CPython. I wrote 3 PEP (509, 510, 511) targeting Python 3.6. Some changes to support FAT Python have already been merged into Python 3.6. We will also see other pending patches to optimize CPython core, and the bytecode project which allows to modify bytecode, it also includes a peephole optimizer written in pure Python. Links: * http://faster-cpython.readthedocs.org/fat_python.html * http://fatoptimizer.readthedocs.org/ * http://bytecode.readthedocs.org/

Alessandro Molina - Moving away from NodeJS to a pure python solution for assets [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/moving-away-from-nodejs-to-a-pure-python-solution-for-assets) The talk covers the complexity of managing an asset transformation pipeline through tools like Grunt and NodeJS, especially during deploy, test suites or when a new development environment has to be configured from scratch, and showcase how this complexity can be dodged by using tools like WebAssets and DukPy. No more need to keep around two languages, two package management systems and manage your dependencies between them by youself. Just pip install your app and have it working. ----- When working with WebApplications it is common to rely on an asset management pipeline to compile scripts, minify css or preprocess images. Most of the tools available today rely on JavaScript to perform those steps and always forced Python developers to rely on NodeJS to have grunt perform the pipeline tasks, coffee-script to compile their CoffeeScript or lessc to build their css. This causes longer setup times for projects newcomers, complex development environment, working with two package managers and dependencies that you use once a week but still need to be there. The talk will showcase the DukPy project and focus on how it is possible to build a pure python asset pipeline relying on DukPy to run javascript tools and WebAssets framework to perform the most common tasks that usually Nodejs and tools like Grunt handle for us, greatly reducing the development environment complexity and making its setup as simple as ‘pip install’. The talk aims at explaining the complexity of managing an asset transformation pipeline through tools like Grunt, especially during deploy, test suites or when a new development environment has to be created, and showcase how this complexity can be dodged by using tools like WebAssets and DukPy. No more need to keep around two languages, two package management systems and manage your dependencies between them by youself. Just pip install your app and have it working.

Miguel Reguero/Rodrigo Núñez - Cybersecurity in the financial sector with Python [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/ciberseguridad-en-el-sector-financiero-con-python) When people talk about cybersecurity they often think about ethical hacking and exploits, that is but a fraction of what cybersecurity is about, today we are going to talk about another aspect, which is often deemed as not too important.

Fabio Pliger/Marc-André Lemburg - EuroPython 2017: Help us build the next edition! [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/europython-2017-help-us-build-the-next-edition) We need help with organizing and running EuroPython 2017. In this session, we will explain how the EuroPython workgroup model works and where you could help. ----- We need help with organizing and running EuroPython 2017 In this session, we will explain how the EuroPython workgroup model works and where you could help.

Fabio Pliger/Marc-André Lemburg - EPS General Assembly [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/eps-general-assembly) This is where the EuroPython Society (EPS) board gives its reports, resolutions are passed and the EPS members can vote in a new EPS board.

Helen Sherwood-Taylor - Managing Mocks [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/managing-mocks) Mocking is a valuable technique for writing tests but mocking effectively is often a stumbling block for many developers and can raise questions about its overall value as a technique. There will be a brief introduction to mocking, then a look at features and techniques of Python’s unittest.mock library and cover some useful tips and common scenarios, so this will be useful to those who have some experience mocking but would like to do so more effectively. ----- Mocking is a valuable technique for writing tests but mocking effectively is often a stumbling block for many developers and can raise questions about its overall value as a technique. The audience will have some familiarity with unit testing and may have tried mocking before, but some introduction will be provided for those who haven’t. We will look at some features and techniques of Python’s unittest.mock library and cover some useful tips and common scenarios, so this will be useful to those who have some experience mocking but would like to do so more effectively. Summary of proposed content: 1. A short introduction to what mocking is and why it is useful. 2. Tour of Python’s mock library and how to make the most of it * Creating and manipulating Mock objects * Setting up return values and side effects to control test environment * Inspecting mocks - different ways to examine a mock object and find out what happened during the test * How and where to patch 3. Common mocking situations - scenarios where mocking is particularly useful and/or tricky to get right. For example - date/time, filesystem, read only properties 4. Some discussion of when mocking is and isn't helpful. Focus will be mainly on Python's unittest.mock module but we will also have a brief look at some other useful libraries.

Mihai Iachimovschi - Real virtual environments without virtualenv [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/real-virtual-environments-without-virtualenv) Virtualenv is a great tool for the development environment but it's definitely not suitable for every use case. Also, Docker is great for running the application in production, but not everyone that use it in production tried to use it in the development environment. Why not use the same tool from the beginning of the project and until it hits the production in a uniform stack of tooling? This talk will show use cases of using Docker in the process of development as well. ----- The process of developing using Python is very straightforward and easy. Still, each and every developer has his own style of developing and building his entire dev environment. Most of us use virtualenvs which are reliable and comfortable to use. But there are some issues. For instance, the repeatability and immutability of the built environment are not guaranteed. Virtualenv does a lot of work that targets the direction of somehow isolated and independent environments. They are *almost* *fully* repeatable. In any team, we can hear the notorious expression "It works for me!". For some time now, I am using Docker instead of virtualenv for building custom and really-virtual environments that are entirely isolated. The containers are immutable and consistent, so this workflow guarantees repeatability. Using such technique, not only enables the user to have unique and immutable environments, it also allows de developer to create full app architecture that can then be tested and deployed as is. So the production version will be in identical conditions as the one from the development environment. These features are not provided by virtualenv at all. The goal of this exercise is to try to use totally different tooling for building the application from its first line of code until the production.

Daniele Procida - Documentation-driven development [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/documentation-driven-development) One secret of Django's success is the quality of its documentation. As well as being key to the quality of the code itself, it has helped drive the development of Django as a community project, and even the professional development of programmers who adopt Django. I'll discuss how Django has achieved it, and how any project can easily win the same benefits. ----- Part of my job title is _Documentation Manager_. When I explain this to a programmer outside the Python/Django community, the reaction can be anything from bewilderment to a kind of mild horror. When I mention it to a Python/Django programmer, the response is usually: _Oh, cool_. In fact, one secret of Django's success is the quality of its documentation, and everyone who uses Django is quick to note this. The returns on Django's investment have been substantial, but some of them are also surprising. The documentation has clearly been key to the _quality of the code itself_, but also (less obviously) to the _development of Django as a community project_, and even the _professional development of programmers_ who adopt Django. I'll discuss how Django has achieved it, and how any project can easily win the same benefits.

Catherine Holloway - Simplifying Computer Art in Python [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/simplifying-computer-art-in-python) The Processing project demonstrated that computer art can attract a wider audience to programming. Python has a robust catalog of libraries, including two interfaces to OpenGL. However, none of these libraries replicate Processing’s simplicity when drawing to the screen. I will present my solution to this problem: a re- implementation of VPython’s visual module purely in python called PygletHelper. ----- Processing is a programming language originally developed by the MIT media lab with the goal of allowing artists, educators, and many others develop striking computer generated or assisted projects without requiring deep knowledge of software engineering or computer graphics. Like Processing, Python has become a favourite language of users from diverse backgrounds, such as web development, education, and science. Unlike Processing, python lacks a simple and easy to use library for drawing shapes. Python’s existing libraries for scientific computing and data analysis could be made even more awesome when combined with a simple drawing library. VPython contains a module called visual that established a simple API and convention for drawing shapes, however it was written in C++, prior to the development of pyglet, and thus is not entirely cross- platform. In this talk, I will demonstrate my solution to this problem: a re-implementation of visual purely in Python called PygletHelper. Pyglet, an existing python library, provides a python interface to OpenGL. PygletHelper is built on pyglet but obscures all of the OpenGL calls, such that the user can draw simple geometric shapes to the screen and animate them without needing to know about computer graphics terminology, memory usage, or C data types. I will also show some need visualizations of science and music in my talk, as well as the graphical glitches encountered implementing the library.

Rudy Sicard - Leveraging documentation power for better web APIs [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/leveraging-documentation-power-for-better-web-apis) Web APIs that are easier to understand, develop, test and use, is a popular subject. "An API is only as good as its documentation". We decided to play with this proverb and leverage the power of documentation. We propose to use the code documentation and the type system to provide lots of free features: explorable APIs, better error messages, automatic testing. Python is perfect to explore code and documentation dynamically. We'll demonstrate what we came up to and the lessons we've learned. ----- 'Rich' web APIs that are easier to understand, develop, test and use, is a popular subject. There are a lot of new specification languages (e.g. swagger, apiblueprint ...) and libraries (django-rest-framework, drf ...) that provide features in this direction. Following the old proverb "An API is only as good as its documentation", we decided to play with these ideas and focus on leveraging the power of documentation. We propose to use the code documentation and the type system to provide: - browsable APIs, that are easy to interact with and visualize, reducing the need to provide custom UIs - verification of inputs/outputs along with precise error message if needed - automatic [de]-serialization of inputs/ouputs outside of the domain code - smart exception handling, e.g. exceptions that are not documented are automatically converted into internal errors - automatic testing, e.g. input, output and result including exceptions are tested ensuring the code works and the documentation is up-to-date. This use case is one of the rare situation where introspection is desirable and unavoidable. And Python is a good language to explore/exploit code and documentation dynamically. The perfect excuse to spend some time on meta coding a first implementation while being at work. We'll demonstrate what we came up to, the advantages and limitations compared to other approaches. And we'll share the lessons we learned from this experiment.

Andrii Soldatenko - What is the best full text search engine for Python? [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/what-is-the-best-full-text-search-engine-for-python) Compare full text search engines for Python. ----- Nowadays we can see lot’s of benchmarks and performance tests of different web frameworks and Python tools. Regarding to search engines, it’s difficult to find useful information especially benchmarks or comparing between different search engines. It’s difficult to manage what search engine you should select for instance, ElasticSearch, Postgres Full Text Search or may be Sphinx or Whoosh. You face a difficult choice, that’s why I am pleased to share with you my acquired experience and benchmarks and focus on how to compare full text search engines for Python.

Iwan Vosloo - What's the point of Object Orientation? [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/whats-the-point-of-object-orientation) This talk covers the basics of what Object Orientation (OO) is really about. It focusses on the problem OO is aimed at solving and shows where the OO mechanisms of Python fit into this picture. This material can serve as an introduction to OO for beginners, but also as a homing signal for experienced programmers who are doubting whether they are reaping the benefits OO promises. ----- Object Orientation (OO) is often introduced in terms of how it is implemented by a specific language. However, understanding the theory underlying OO is not quite the same as understanding how OO concepts are supported by a particular language. It is insightful to understand the simple OO fundamentals and how these map to the particular implementation provided by Python. In this talk I will first explain the very basics of OO from a language-neutral point of view with the aim of showing what OO can offer you and to give a glimpse of the simple mathematical theory underlying OO. I hope to give you enough information to help you distinguish between better and worse designs and to detect whether you’re using OO as it was intended. I will also very briefly show how these fundamentals map to Python. This talk is for anyone: whether you’re new at Object Orientation, or a practitioner wondering whether OO is worth the effort you’ve spent trying to use it.

Naomi Ceder - Come for the Language, Stay for the Community [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/keynote-stay-for-the-community) While Python the language is wonderful, the Python community and the personal, social, and professional benefits that flow from involvement in a community like ours are often more compelling. Learn about the goals of the Python Software Foundation and how everyone can take part to help build even better Python communities locally, regionally, and globally. I will also discuss some of our strengths as a community, and also look at some of the challenges we face going forward. ----- Python is a powerful and flexible tool that many of us love and use in many ways. And yet, as wonderful as the language is, many would say that the community is even more attractive. This talk will focus on involvement in the Python community and what that means - in particular the many personal, social, and professional benefits that flow from involvement in a community like ours. I will also discuss what the Python Software Foundation does, what its goals and purpose are, and how everyone in the community can take part in the PSF to help build even better Python communities. This will include specific explanations of the membership model and how active contributors (both in terms of code and community organisation) can and should become full voting members of the PSF. I will also touch on our strengths, like our commitment to safe and inclusive spaces and our devotion to education, and also look at some of the challenges we face as a community going forward.

Lauris Jullien - Asynchronous network requests in a web application [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/asynchronous-network-requests-in-a-web-application) Introducing asynchronous calls from within an endpoint in a web app can be desirable but hard to achieve. This talk will explore different solutions for this (running Twisted event loop, Co-Routines, Asyncio, …) and how well they play with the different parallelization models of common WSGI web servers. ----- In the more and more popular SOA paradigm, it’s common for services to have to compose responses with resources from many different services. Everyone’s first idea will probably be to call each service synchronously with your favorite python HTTP library. This unfortunately doesn’t scale well and tens of successive network calls will make your endpoints painfully slow. One solution is to parallelize these network calls. If you are already using an asynchronous web app (such as Tornado or Twisted), more asynchronous in your asynchronous shouldn’t be much of a challenge. But if you chose not to dive into the madness of chained Deferred calls, and used a standard prefork/threaded WSGI web server (such as Gunicorn or uWSGI) to run your Django/Flask/Pyramid application, you might find yourself wondering how to manage these asynchronous calls. This talk will explore different solutions (running Twisted event loop, Co-Routines, Asyncio, …) and how well they play with the different parallelization models of WSGI web servers.

Raphael Pierzina - Pytest 3.0 [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/pytest-30) - New features of pytest's upcoming major version 3.0 - Breaking changes and other important information - Recap of the first developer sprint in June, 2016 - Thank you notes to all who have contributed to the fundraiser ----- Pytest is a mature testing framework for Python that is developed by a thriving and ever-growing community of volunteers. Following the principle of "no API is the best API" it uses plain assert statements and regular Python comparisons. Writing tests with pytest requires little to no boilerplate code and powerful features allow easy parametrization and intelligent test selection. In this talk we will have an in-depth look at new features of pytest 3.0 and live demo possible use cases. We will also learn about important bugfixes and other enhancements of the upcoming major release. Backwards-incompatible changes will be addressed and changes made to the documentation will be highlighted. If you are already familiar with pytest, you will be happy to hear about significant improvements of the fixture and hook system but also what's in store for a better integration with tox, an important tool that allows testing across different Python versions. In June, 2016 more than 25 Pythonistas from around the globe gather in Freiburg, Germany to work on the release and set the path for future developments of the core framework. This is a big step forward for the project made posssible by a fundraiser that reached 108% of it's initial goal. I will share our experiences from the developer sprint while they are still fresh and explain why these events are incredibly important for a community and give advice on how to organize your own.

Yury Selivanov - async/await in Python 3.5 and why it is awesome [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/asyncawait-in-python-35-an-why-it-is-awesome) async/await is here, everybody can use it in Python 3.5. It's great and awesome, yet only a few understand it. As a PEP 492 author, I'd really like to have a chance to better explain the topic, show why async/await is important and how it will affect Python. I'll also tell a story on how I worked on the PEP -- starting from an idea that I discussed with Guido on PyCon US 2015, and landing to CPython source code one and a half moths later! ----- The talk will start with a brief coverage of the story of asynchronous programming in Python -- Twisted, Tornado, Stackless Python & greenlets, eventlet, Tornado, asyncio & curio. We've come a really long road, and it's important to understand how we ended up with async/await. Then I'll go over asyncio and curio, showing async/await by example, explaining that in reality it's a very easy to use language feature. You don't need to know all the details to be able to successfully use the new syntax, and even build new frameworks on top of it. I'll then explain the async/await machinery in CPython, starting with generators and 'yield' expression, showing what is 'yield from' and finally, demonstrating how async/await is implemented in CPython. This will ensure that those who want to invent some new crazy ways of using async/await will have a starting point! I'll end the talk with a story of how I came up with the idea. How I shared it with Guido van Rossum, Victor Stinner, and Andrew Svetlow. How the first version of the PEP was born, and how we managed to push it to Python 3.5 in under two months period. The goal is to make people understand that it's possible to change your programming language -- in fact, Python, as any other programming language, wants new features and capabilities to be relevant.

Floris Bruynooghe - Build your Microservices with ZeroMQ [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/build-your-microservices-with-zeromq) While microservices are rather commonly implemented using JSON over HTTP this is merely an implementation choice. This talk will cover the reasons why you might want to choose ZeroMQ as communication transport between your microservices instead. It will show how ZeroMQ is used from within Python and the common patterns which can simplify the overal architecture while at the same time providing reliable and low-latency communications between your services. ----- Microservices is the popular term for the trend to build backend architectures as a number of smaller independent processes. As an evolution from the Service Oriented Architecture the core aims are to create independent services which are easy to operate and even replace while all of them together compose into providing the business logic required for your application. While it is rather common for microservices to choose JSON over HTTP to communicate with each other, this is purely an implementation choice. HTTP is a protocol using a strict request-response format, this can become a little burdensome when needing to deal with asynchronous requests and forces some architectural descisions to be not as ideal as they could be. ZeroMQ has more flexible communication patterns allowing for easier mapping of real-life interactions between services. Coupled with an easy to use asynchronous user-level API and very fast underlying communication on persistent TCP connections ZeroMQ is a rather attractive transport to build your microservices based applications in. This talk will show how to use ZeroMQ within Python to build your microservices. It will show the benefits of ZeroMQ's asynchronous API, common usage patterns and how to handle backpressure. Furthermore different communication patterns will be explored and the impact this has on how to simplify the overall architecture using these patterns.

Anna Wszeborowska - Music transcription with Python [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/music-transcription-with-python) Music transcription allows to convert an audio recording to musical notation through mathematical analysis. In the talk we will focus on transcribing a monophonic audio input and see how we can modify it on the fly. To achieve that, we need to determine pitch and duration of each note, and then use these parameters to create a sequence of MIDI events. ----- Music transcription allows to convert an audio recording to musical notation through mathematical analysis. It is a very complex problem, especially for polyphonic music - currently existing solutions yield results with approx. 70% or less accuracy. In the talk we will focus on transcribing a monophonic audio input and see how we can modify it on the fly. To achieve that, we need to determine pitch and duration of each note, and then use these parameters to create a sequence of MIDI events. MIDI stands for _Musical Instrument Digital Interface_ and it encodes commands used to generate sounds by musical hardware or software. Let's see how to play around with sounds using Python and a handful of its powerful libraries. And let's do it in real-time!

Fabio Pliger - OMG, Bokeh is better than ever! [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/omg-bokeh-is-better-then-ever) Bokeh is a unique library in its genre that lets users create beautiful and complex visualizations from Python. The talks shows a comprehensive overview of the most powerful and popular Bokeh features, like: the optimized websocket based server for performant python callbacks from actions on the browser, Javascript callbacks written in Python (YES!!), bokeh command that lets target different outputs from the same input, JS transforms from Python, high-level charts, Geo support, ... ----- Bokeh is a unique library in its genre that lets users create beautiful and complex visualizations from Python (and other languages) to the browser without actually writing Javascript or HTML. In the last year the Bokeh team have added a large number of unique features that are extremely powerful. Fully optimized websocket based server that enables performant python callbacks from actions on the browser, Javascript callbacks written in Python (YES!!), bokeh command that lets target different outputs from the same input, JS transforms from Python, high-level charts, Geo support, ... Anyone interested in powerful and easy visualizations should take a look at it. :)

Valerio Maggio - Data Formats for Data Science [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/data-science-formats-beyond-csv-and-hdfs) The CSV is the most widely adopted data format. It used to store and share *not-so-big* scientific data. However, this format is not particularly suited in case data require any sort of internal hierarchical structure, or if data are too big. To this end, other data formats must be considered. In this talk, the different data formats will be presented and compared w.r.t. their usage for scientific computations along with corresponding Python libraries. ----- The *plain text* is one of the simplest yet most intuitive format in which data could be stored. It is easy to create, human and machine readable, *storage-friendly* (i.e. highly compressible), and quite fast to process. Textual data can also be easily *structured*; in fact to date the CSV (*Comma Separated Values*) is the most common data format among data scientists. However, this format is not properly suited in case data require any sort of internal hierarchical structure, or if data are too big to fit in a single disk. In these cases other formats must be considered, according to the shape of data, and the specific constraints imposed by the context. These formats may leverage *general purpose* solutions, e.g. [No]SQL databases, HDFS (Hadoop File System); or may be specifically designed for scientific data, e.g. hdf5, ROOT, NetCDF. In this talk, the strength and flaws of each solution will be discussed, focusing on their usage for scientific computations. The goal is to provide some practical guidelines for data scientists, derived from the the comparison of the different Pythonic solutions presented for the case study analysed. These will include `xarray`, `pyROOT` *vs* `rootpy`, `h5py` *vs* `PyTables`, `bcolz`, and `blaze`. Finally, few notes about the new trends for **columnar databases** (e.g. *MonetDB*) will be also presented, for very fast in-memory analytics.

Sławomir Piasecki - Python in Astronomy [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/python-in-astronomy) I would like to talk about modern Astronomy where I would give a brief history of Astronomy. I will answer some question: What do we use computers for today in astronomy? Where is Python’s place in today’s science? Is Python is the best language for scientific computation? I would like to give a short introduction into AstroPy module. Finally I would like presents some result of my research where Python was used to create data. ----- For ages people have been watching the sky, and tried to learn something about all those mysterious lights. In ancient times, scientist used mostly their naked eyes to watch what happened in the night sky. Astronomy is one of the oldest fields in science. Everything changed when Galileo invented his lunette. Thanks to thi, we were able to proof Copernicus’ new model of the solar system with the sun in the center. The next big step in Astronomy was using computers. Where there are computers and Astronomy, there is a place for programming. For many years astronomers were mostly using Fortran and C/C++. Both are suited to numeric computation and scientific computing. Since they are structured programming language, that makes them very valuable for science. Over the past decade, Python has started to be used by more and more people in astronomy. But is there a place in Astronomy for Python, as it is not as fast as Fortran or C/C++? In Python there is a module called AstroPy which helps astronomers in their work. MatPlotLib is one of the most popular library use in astronomy. This tool helps created very sophisticated plots and graphs. Finally I would like talk about some research I did using Python. For research, we decided to use AUTO. It is a hybrid of Fortran and Python, to compute bifurcation points in mathematical models. In Python we introduce mathematical model, ODE and initial parameters. Fortran does all the computation.

Joe Drumgoole - A deep dive into the Pymongo MongoDB driver [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/a-deep-dive-into-the-pymongo-mongodb-driver) The Pymongo driver is one of MongoDB’s most popular driver interfaces for connecting to MongoDB. But developers rarely look under the cover to see what’s happening inside the driver. By having a deeper insight into how the driver constructs server requests and responds, developers will be able to write more effective MongoDB applications in Python. ----- *The Pymongo driver is one of MongoDB’s most popular driver interfaces for connecting to MongoDB. But developers rarely look under the cover to see what’s happening inside the driver. * *By having a deeper insight into how the driver constructs server requests and responds, developers will be able to write more effective MongoDB applications in Python.* *We will look at :* - *Initial connection* - *A query* - *A simple write operation* - *A bulk write operation* - *How the driver responds when we have a node failure* *We will also give insight into the driver’s approach to server selection when connecting to a replicas set (a multi-node instance of MongoDB).*

Valeria Pettorino - Unveiling the Universe with python [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/unveiling-the-universe-with-python) I will describe a scientific application of python in the field of Astrophysics and Cosmology. How the publicly available package Monte Python is used to compare data from space satellite missions with theoretical models that attempt to describe the evolution and content of the Universe. The result is surprising, as it points towards a Universe which is mainly dark. ----- Python is widely used in Cosmology, which is the study of the Universe and all forms of energy in it. A large amount of data has been recently obtained through space satellite missions, such as Planck, financed by ESA/NASA. Planck has observed the radiation emitted about 13 billion years ago (the Cosmic Microwave Background, CMB), which gives us information on the content and space-time geometry of the Universe. Many competitive theoretical models have been proposed that aim at describing the evolution of the species contained in the Universe: therefore, cosmologists need a method to identify which theoretical model better fits the data. In order to compare data with theoretical predictions, cosmologists use Bayesian statistics and Monte Carlo simulations. Among the tools developed for the analysis, the package ‘Monte Python’ is publicly available and uses python to perform Monte Carlo simulations: this allows to determine the theoretical model that maximizes the likelihood to obtain the observed data. Such model is now the standard cosmological model and reveals a Universe that is very different from what scientists had ever expected. A Universe in which the atoms we are made of, constitute only 5% of the total energy budget. The rest is the so-called ‘Dark Universe’. I will illustrate the story of how cosmologists used python to analyse the data of the CMB and unveil the Dark Universe.

Alexander Steffen - Writing unit tests for C code in Python [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/writing-unit-tests-for-c-code-in-python) There are many unit testing frameworks for C out there, but most of them require you to write your tests in C (or C++). While there might be good reasons to keep your implementation in C, those hardly apply to the tests. So wouldn't it be nice to use all the power of Python and its unit testing capabilities also for your C code? This talk will show you how. ----- There are many unit testing frameworks for C out there, but most of them require you to write your tests in C (or C++). While there might be good reasons to keep your implementation in C (for example execution speed or resource consumption), those hardly apply to the tests. So wouldn't it be nice to use all the power of Python and its unit testing capabilities also for your C code? This talk will show you how to combine CFFI and pycparser to easily create Python unit tests for C code, without a single line of C anywhere in the test cases. It will also cover creating mock functions in Python, that can be used by the C code under test to hide external dependencies. Finally, we will look at some of the challenges you might face when trying to mix Python and C and what to do about them.

Fabien Bochu - Grocker, a Python build chain for Docker [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/grocker-a-python-build-chain-for-docker) Grocker is a Docker build chain for Python. It transforms your Python package into a self-contained Docker image which can be easily deployed in a Docker infrastructure. Grocker also adds a Docker entry point to easily start your application. ----- At Polyconseil, we build Paris electric car sharing service: Autolib'. This system is based on many services developed using web technologies, Django and our own libraries to handle business logic. Packaging is already a difficult problem, deploying large Python projects is even more difficult. When deploying on a live and user- centric system like Autolib', you cannot rely on Pip and external PyPI servers which might become unavailable and are beyond your control. In the beginning we used classic Debian packaging: it was a maintenance hell. It took hours to build our packages and update their metadata to match our Python packages. So we switched to Docker. Docker allows us to have a unique item that is deployed in production systems: code updates are now atomic and deterministic! But before deploying the Docker image, you need to build it. That's where Grocker comes in. Grocker is a Docker build chain for Python. It will transform your Python package into a self-contained Docker image which can be easily deployed in a Docker Infrastructure. Grocker also adds a Docker entry point to easily start your application.

iztok kucan/Joris Peeters - Algorithmic Trading with Python [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/algorithmic-trading-with-python) This is a look behind the scenes at Winton Capital Management- one of Europe’s most successful systematic investment managers. The talk will mainly focus on how Python gives researchers fine-grained control over the data and trading systems, without requiring them to interact directly with the underlying, highly-optimised technology. ----- Have you ever wondered what technologies are used in a systematic trading system that utilises computer models and accounts for the majority of trading on the stock market? This is a look behind the scenes at Winton Capital Management- one of Europe’s most successful systematic investment managers. In this talk, we’ll run through an overview of Winton’s trading infrastructure, including data management, signal generation and execution of orders on global exchanges. The talk will mainly focus on how Python gives researchers fine-grained control over the data and trading systems, without requiring them to interact directly with the underlying, highly- optimised technology.

Alexys Jacob/Guillaume Gelin - Planning for the worst [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/planning-for-the-worst) Sharing our worst production experiences and the tricks, good practices and code we developed to address them. ----- This talk is about sharing our experience about how we handled production problems on all levels of our applications. We'll begin with common problems, errors and failures and dig on to more obscure ones while sharing concrete tips, good practices and code to address them ! This talk will make you feel the warmth of not being alone facing a problem :)

Andreas Dewes - Analyzing Data with Python & Docker [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/analyzing-data-with-python-docker) Docker is a powerful tool for packaging software and services in containers and running them on a virtual infrastructure. Python is a very powerful language for data analysis. What happens if we combine the two? We get a very versatile and robust system for analyzing data at small and large scale! I will show how we can make use of Python and Docker to build repeatable, robust data analysis workflows which can be used in many different contexts (possibly with a live demo). ----- Docker is a powerful tool for packaging software and services in containers and running them on a virtual infrastructure. Python is a very powerful language for data analysis. What happens if we combine the two? We get a very versatile and robust system for analyzing data at small and large scale! I will show how we can make use of Python and Docker to build repeatable, robust data analysis workflows that can be used in many different contexts. I will explain the core ideas behind Docker and show how they can be useful in data analysis. I will then discuss an open-source Python library (Rouster) which uses the Python Docker-API to analyze data in containers and show several interesting use cases (possibly even a live-demo). Outline: 1. Why data analysis can be frustrating: Managing software, dependencies, data versions, workflows 2. How Docker can help us to make data analysis easier & more reproducible 3. Introducing Rouster: Building data analysis workflows with Python and Docker 4. Examples of data analysis workflows: Business Intelligence, Scientific Data Analysis, Interactive Exploration of Data 5. Future Directions & Outlook

Jose Manuel Ortega - Ethical hacking with Python tools [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/ethical-hacking-with-python-tools) Python, as well as offering an ecosystem of tools for testing security and application pentesting.Python offers a tool ecosystem for developing our own tools security for testing applications and the servers security,identifying information about servers and potential vulnerabilities. The ultimate objective is show a pentesting tool integrating some of the modules commented and try a demo showing info about our domain target and find vulnerabilities in it, ----- Nowdays, Python is the language more used for developing tools within the field of security. Many of the tools can be found today as port scanner, vulnerability analysis, brute force attacks and hacking of passwords are written in python. The goal of the talk would show the tools available within the Python API and third-party modules for developing our own pentesting and security tools and finally show a pentesting tool integrating some of the modules. The main topics of the talk could include: **1.Enter Python language as platform for developing security tools** Introduction about the main libraries we can use for introducing in development of security tools such as socket and requests. **2.Libraries for obtain servers information such as Shodan, pygeocoder,pythonwhois** Shodan is a search engine that lets you find specific computers (routers, servers, etc.) and get information about ports and services that are opened. **3.Analysis and metadata extraction in Python for images and documents** Show tools for scraping web data and obtain metadata information in documents and images **4.Port scanning with tools like python-nmap** With python-nmap module we can check ports open for a target ip or domain. **5.Check vulnerabilities in FTP and SSH servers** With libraries like ftplib and paramiko we can check if the server is vulnerable to ftp and ssh anonymous connections.

Anjana Vakil - Using and abusing Python’s double-underscore methods and attributes [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/using-and-abusing-pythons-double-underscore-methods-and-attributes) Python’s double-underscore ('`__`') methods and attributes go by many names, including “special”, “dunder”, and “magic”. You already use some, like `__init__`, but there are many more! In this talk, we’ll see how dunders can be useful, silly, dangerous, and fun! We’ll trick Python’s arithmetic and comparison operators. We’ll make objects behave like dictionaries and containers. We’ll reduce an object’s memory usage, and speed up membership tests. We’ll even try some naughty function hacks! ----- The curious Python methods and attributes surrounded by double underscores ('`__`') go by many names, including “special”, “dunder”, and “magic”. You probably use some of them, like `__init__`, every day. But that’s just the tip of the iceberg! In this talk, we’ll explore the weird and wonderful world of the double-underscore, and find out how dunders can be useful, silly, dangerous, and just fun! We’ll play pranks on Python’s builtin operators for arithmetic and comparison. We’ll make arbitrary objects behave like dictionaries and containers. We’ll reduce an object’s memory usage, and speed up tests for membership. We’ll even try some naughty function hacks that we should never use in real life! You'll get the most out of this talk if you're already comfortable writing object-oriented Python code. If you already use special dunder magic in your own code, that's excellent! You’ll have a chance to share your tips & tricks with the rest of the audience at the end of the talk. _Talk repo_: [https://github.com/vakila/dunders][1] [1]: https://github.com/vakila/dunders

Adam Dangoor - Another pair of eyes: Reviewing code well [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/another-pair-of-eyes-reviewing-code-well) Many of us have been taught to code, but we know that software engineering jobs are so much more than that. Programmers can spend 5-6 hours per week on code review, but doing that is almost ignored as a skill. How many of us have seen poor reviews, which don't catch bugs, make people feel bad or block important features being merged? An introduction to what code review is alongside guidelines, tips, tricks and anecdotes to help make your code reviews be as productive as possible. ----- Many of us have been taught to code, but we know that software engineering is so much more than that. Programmers can spend 5-6 hours per week on code review, but doing that is almost ignored as a skill, and instead it is often treated as a rote chore. How many of us have seen poor reviews - those which upset people, don't catch bugs or block important features being merged? This talk explores the social and technical impacts of various code review practices as well as helpful tooling. The goal is to provide a structure to help improve how teams review code, and to introduce the costs and benefits of code review to anyone unfamiliar with the practice. There are always trade-offs to be made - e.g. think how costly a security flaw in this code could be to your organisation - perhaps intense scrutiny is not necessary for prototypes soon to be thrown away. It is useful to consider the trade-offs in order to optimise for a particular problem domain. Perhaps right now it is more important to look for issues with maintainability, functionality or performance. I talk about how some fantastic code reviews from mentors, colleagues and strangers have helped me become a better programmer and team member, as well as occasions where code review has been detrimental by slowing things down and causing arguments. This is aimed at everyone from beginner to advanced programmers.

James Saryerwinnie - Writing Redis in Python with asyncio [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/writing-redis-in-python-with-asyncio) In this talk, I'll show you how to write redis using asyncio. You'll see how you can create a real world application using asyncio by creating a python port of redis. ----- Python has been adding more and more async features to the language. Starting with asyncio in python 3.4 and including the new async/await keywords in python 3.5, it's difficult to understand how all these pieces fit together. More importantly, it's hard to envision how to use these new language features in a real world application. In this talk we're going to move beyond the basic examples of TCP echo servers and example servers that can add number together. Instead I'll show you a realistic asyncio application. This application is a port of redis, a popular data structure server, written in python using asyncio. In addition to basic topics such as handling simple redis commands (GET, SET, APPEND, etc), we'll look at notifications using pub/sub, how to implement the MONITOR command, and persistence. Come learn how to apply the asyncio library to real world applications.

John Kraal - High Availability Scaling with Share Nothing Architecture [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/high-availability-scaling-with-share-nothing-architecture) Scaling a project to a worldwide scale with the same performance and availability in every region using Python isn’t easy, but with the right mindset and tools it’s a very viable target. ----- We will discuss methods of delivering software, with automated scaling systems, building units out of your project to manage separately and how to reliably and securely distribute data to separate clusters, and how we have achieved this with the use of Celery, Redis, Databases, Protobuf and other modern tools, whilst making sure to highlight our pitfalls and successes

Rogier van der Geer - How to conquer the world [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/a-genetic-algorithm-to-play-the-game-of-risk) The popular board game of Risk has many fans around the world. Using a Python-based simulation of the game, we use a genetic algorithm to train a risk-playing algorithm. ----- During this talk we'll explain what genetic algorithms are and we'll explain an entertaining use-case: how to win at popular board games. During the talk we'll demo how object oriented patterns help with the design and implementation of these algorithms. We'll also demonstrate a library that allows users to push their own risk bots into a game and battle it out on.

Katharine Jarmul - I Hate You, NLP... ;) [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/i-hate-you-nlp) In an era of almost-unlimited textual data, accurate sentiment analysis can be the key for determining if our products, services and communities are delighting or aggravating others. We'll take a look at the sentiment analysis landscape in Python: touching on simple libraries and approaches to try as well as more complex systems based on machine learning. ----- Overview ------------- This talk aims to introduce the audience to the wide array of tools available in Python focused on sentiment analysis. It will cover basic semantic mapping, emoticon mapping as well as some of the more recent developments in applying neural networks, machine learning and deep learning to natural language processing. Participants will also learn some of the pitfalls of the different approaches and see some hands-on code for sentiment analysis. Outline ----------- * NLP: then and now * Why Emotions Are Hard * Simple Analysis * TextBlob (& other available libraries) * Bag of Words * Naive Bayes * Complex Analysis * Preprocessing with word2vec * Metamind & RNLN * Optimus & CNN * TensorFlow * Watson * Live Demo * Q&A

Ralph de Wargny - High Performance Python on Intel Many-Core Architecture [EuroPython 2016] [21 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/high-performance-python-on-intel-architecture) This talk will give an overview about the Intel® Distribution for Python which delivers high performance acceleration of Python code on Intel processors for scientific computing, data analytics, and machine learning. ----- In the first part of the talk, we'll look at the architecture of the latest Intel processors, including the brand new Intel Xeon Phi, also known as Knights Landing, a many-core processor, which was just released end of June 2016. In the second part, we will see which tools and libraries are available from Intel Software to enable high performance Python code on multi-core and many-core processors.

Anthon van der Neut - Beyond scraping [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/beyond-scraping-getting-data-from-dynamic-heavily-javascript-driven-websites) This talk show how a to create a simple, evolving, client server architecture combining zeromq, selenium and beautifulsoup, which allows you to scrape data even from variable dynamic sites like Sporcle and KhanAcademy. Once the page analysis has been implemented regular "downloads" can easily be deployed without cluttering your desktop, your headless server and/or anonymously. ----- Scraping static websites can be done with `urllib2` from the standard library, or with some slightly more sophisticated packages like `requests`. However as soon as JavaScript comes into play on the website you want to download information from, for things like logging in via openid or constructing the pages content, you almost always have to fall back to driving a real browser. For web sites with variable content this is can be time consuming and cumbersome process. This talk show how a to create a simple, evolving, client server architecture combining zeromq, selenium and beautifulsoup, which allows you to scrape data from sites like Sporcle, StackOverflow and KhanAcademy. Once the page analysis has been implemented regular "downloads" can easily be deployed without cluttering your desktop, your headless server and/or anonymously. The described client server setup allows you to restart your changed analysis program without having to redo all the previous steps of logging in and stepping through instructions to get back to the page where you got "stuck" earlier on. This often decreases the time between entering a possible fix in your HTML analysis code en testing it, down to less than a second from a few tens of seconds in case you have to restart a browser. Using such a setup you have time to focus on writing robust code instead of code that breaks with every little change the sites designers make.

Víctor Terrón - Kung Fu al amanecer con itertools [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/kung-fu-al-amanecer-con-itertools) El módulo itertools es una de las piedras angulares de la programación avanzada en Python. Esta charla proporciona consejos prácticos del álgebra de iteradores que pueden aplicarse de forma inmediata. Descubrir el módulo itertools supone arrancar el velo de nuestros ojos, y una vez usadas funciones como `repeat()`, `takewhile()`, `dropwhile()` o `product()` no hay marcha atrás — es imposible volver al mundo de los meros mortales donde las soluciones son más complejas y necesitan más memoria. ----- El módulo itertools es una de las piedras angulares de la programación avanzada en Python. Parte de la biblioteca estándar, nos ofrece un álgebra de iteradores que permite encadenar abstracciones de forma elegante, haciendo posibles soluciones sencillas a la par que más eficientes en su consumo de memoria. El objetivo de esta charla es el de, ante todo, proporcionar consejos y lecciones claras que puedan aplicarse de forma inmediata. Ilustrándolo con numerosos ejemplos, los asistentes abandonarán la charla habiendo asimilado como mínimo varios conceptos que mejorarán indiscutible e irremediablemente su código. El énfasis se hará en mostrar casos específicos en los que una solución tradicional puede ser mejorada una y otra vez con funciones del módulo itertools. Supongamos, por ejemplo, que queremos alternar indefinidamente entre dos valores: -1 y 1. El recién iniciado utilizaría una variable cuyo valor iría modificando a cada paso y el usuario medio quizás optaría por un generador infinito. Ambas soluciones dignas y honorables, pero que palidecen ante la maestría del artista marcial que que tan sólo necesita `itertools.cycle()`. Porque el módulo itertools es así: una vez caído el velo de nuestros ojos y descubiertas funciones como `repeat()`, `takewhile()`, `dropwhile()` o `product()`, no hay marcha atrás. En esta charla vamos a aprender a reconocer cuándo pueden ser usadas, proporcionándonos en una única línea lo que para los meros mortales supone mucho más trabajo.

Guillem Duran - Interactive data Kung Fu with Shaolin [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/interactive-data-kung-fu-with-shaolin) “Notebooks come alive when interactive widgets are used”, but programming complex applications that rely entirely on widgets may end up being a painful and frustrating process. Shaolin is a new python project that aims to provide a framework for building interactive complex dashboards. ----- You can read in The Project Jupyter web page that “Notebooks come alive when interactive widgets are used”, but programming complex applications that rely entirely on widgets may end up being a painful and frustrating process. Shaolin is a new python project that aims to provide a framework for building interactive complex dashboards. Shaolin provides all the basic tools for building complex interactive data analysis applications using the pydata ecosystem. Arbitrary code can be embedded into a Dashboard -a class that works as a “black box” that allows to easily define a GUI based on the ipywidgets package- to process any data in any form and then let you interactively define how to plot it using automatically generated widgets. Hierarchical combinations of Dashboards can be arranged then to build more complex applications. The talk is divided in two sections. First one introduce the framework and its main features: - Custom syntax for defining widgets in a simplified way. - Dashboards: Syntax rules and capabilities. - Combining Dashboards to build complex applications. - Interactive plot creation. - Integration with pydata. Second section will show how this framework can be used to analyse real data using Dashboards without writing any code. I will show how to transform market data time series into graphs using pandas and networkx, then plot it interactively using bokeh and Vpython.

Thierry Carrez/Doug Hellmann - How OpenStack makes Python better (and vice-versa) [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/how-openstack-makes-python-better-and-vice-versa) OpenStack is an infrastructure stack mostly developed in Python. In this talk, Thierry Carrez and Doug Hellmann, both Python Software Foundation fellows and OpenStack Technical Committee members, will look at the symbiotic relationship between OpenStack and Python. ----- OpenStack is an open source stack that can be deployed on raw computing resources to privately or publicly present Infrastructure as a Service. It now consists of more than 4.5 million lines of code, 85% of which is Python. In this talk, Thierry Carrez and Doug Hellmann, both Python Software Foundation fellows and OpenStack Technical Committee members, will look at the symbiotic relationship between OpenStack and Python. We'll go back in history and explain why OpenStack originally picked Python as its main language 6 years ago, and explore what does Python bring to OpenStack. We'll dive into examples of OpenStack pushing Python libraries to their limits and exposing new bugs. We'll look into the massive cloud-based continuous integration system that OpenStack uses and explain how it exposes bugs in Python libraries in the minutes after they are published to PyPI. We'll look into Python libraries that were created by the OpenStack community and libraries that the OpenStack community took over. Finally we'll expose a few best practices that Python developers can follow to get the most of this symbiotic relationship.

Angelo Failla - FBTFTP: Facebook's open source python3 framework for dynamic TFTP servers. [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/fbtftp-facebooks-python3-framework-for-tftp-servers) FBTFTP: facebook's opensource framework for creating dynamic TFTP servers in Python3. ----- TFTP was first standardized in '81 (same year I was born!) and one of its primary uses is in the early stage of network booting. TFTP is very simple to implement, and one of the reasons it is still in use is that its small footprint allows engineers to fit the code into very low resource, single board computers, system-on-a-chip implementations and mainboard chipsets, in the case of modern hardware. It is therefore a crucial protocol deployed in almost every data center environment. It is used, together with DHCP, to chain load Network Boot Programs (NBPs), like Grub2 and iPXE. They allow machines to bootstrap themselves and install operating systems off of the network, downloading kernels and initrds via HTTP and starting them up. At Facebook, we have been using the standard in.tftpd daemon for years, however, we started to reach its limitations. Limitations that were partially due to our scale and the way TFTP was deployed in our infrastructure, but also to the protocol specifications based on requirements from the 80's. To address those limitations we ended up writing our own framework for creating dynamic TFTP servers in Python3, and we decided to open source it. I will take you thru the framework and the features it offers. I'll discuss the specific problems that motivated us to create it. We will look at practical examples of how touse it, along with a little code, to build your own server that are tailored to your own infra needs.

Mircea Zetea - Managing technical debt [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/managing-technical-debt) Technical debt lives among us regardless if we are in the services business or building products. We discuss about it, we try to fix it or live with it, but can we actually prevent it? My reason for discussing this openly is because once it is there you do not only deal with the technical debt itself but also with the interest you must pay. What qualifies as debt? What qualifies as interest? How do we manage it? Is it really unavoidable? ----- Technical debt lives among us regardless if we are in the services business or building products. We discuss about it, we try to fix it or live with it, but can we actually prevent it? My reason for discussing this openly is because once it is there you do not only deal with the technical debt itself but also with the interest you must pay. My reason for discussing this openly is because once it is there you do not only deal with the technical debt itself but also with the interest you must pay. Comparing the two, probably the highest cost that we see is with the interest. As our code base grows and our deadlines get tougher we tend to forget about the cost our project will have to pay for every functionality that we implement in a hurry, for which we “forget” about tests or for which we write in a comment “this needs to be refactored” or “this is a temporary solution. refactor later”. What qualifies as debt? What qualifies as interest? How do we manage it? At what levels in our projects can we see the debt and the interest? Is it really unavoidable?

Andrés Cidel - Create secure production environment using Docker [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/create-secure-production-environment-using-docker) The purpose of this talk if pointing out that using Docker in production is perfectly valid, not just for develop and CI environments. ----- Docker is a relatively new technology platform that helps teams develop, deploy and scale applications with greater ease and speed. However, there are doubts about using Docker in production environments. One important reason is that containers don't provide the same security layer as hypervisors do. The purpose of this talk is pointing out that using Docker in production is perfectly valid, not just for develop and CI environments. We'll learn: - How Docker works. - Main risks. - How create and maintain secure images. - How defend containers. - How delimit security risks in containers. - Best practices for running containers.

Andrei Coman - Effectively test your webapp with Python and Selenium [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/effectively-test-your-webapp-with-python-and-selenium) We will explore the lessons learned on maintaining a Selenium test suite against a webapplication and how to leverage python tools to make this process easy and transparent. ----- How often do you run your Selenium test suite? How fast do you get a result from it? Would you like to answer with: "Whenever I feel like it" and "Well, about the time it takes me to finish a coffee" ? This talk will try to get you closer to these answers. We will have a look at the lessons learned and the challenges my team faced maintaining a Selenium test suite against a long-lived Django web application. We will go over the pros and cons of: - test design approaches - technologies we used (nose, py.test, LiveServerTestCase) - reporting tools

Domen Kožar - What Python can learn from Haskell packaging [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/what-python-can-learn-from-haskell-packaging) Haskell community has made lots of small important improvements to packaging in 2015. What can Python community learn from it and how are we different? ----- Haskell community has been living in "Cabal hell" for decades, but Stack tool and Nix language have been a great game changer for Haskell in 2015. Python packaging has evolved since they very beginning of distutils in 1999. We'll take a look what Haskell community has been doing in their playground and what they've done better or worse. The talk is inspired by Peter Simons talk given at Nix conference: [Peter Simons: Inside of the Nixpkgs Haskell Infrastructure][1] [1]: https://www.youtube.com/watch?v=TDnZsBxqeBM&list=PL_IxoDz1Nq2Y7mIxMZ28mVtjRbbnlVdmy&index=4 Outline: - Cabal (packaging) interesting features overview - Cabal file specification overview - Interesting Cabal features not seen in Python packaging - Lack of features (introduction into next section) - Cabal hell - Quick overview of Haskell community frustration over Cabal tooling - Stack tool overview - What problem Stack solves - How Stack works - Comparing Stack to pip requirements - Using Nix language to automate packaging - how packaging is automated for Haskell - how it could be done for Python

Dmitry Trofimov - Profiling the unprofilable [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/profiling-the-unprofilable) When a program is not fast enough, we call on the profiler to save us. But what happens when the program is hard to profile, like for instance the Python Debugger? In this talk we're going dive deep into Vmprof, a Python profiler, and see how it helps us find out why a debugger can be slow. Once we find the culprit, we'll use Cython to optimise things. ----- Profile is the main way to find slow parts of your application, and it's often the first approach to performance optimisation. While there are quite a few profilers, many of them have limitations. In this talk we're going to learn about the new statistical profiler for Python called Vmprof that is actively being developed by the PyPy team. We'll see how it is implemented and how to use it effectively. We will apply it to an open source project, the Pydev.Debugger, a popular debugger used in IDE's such as Pydev and PyCharm, and with the help of Cython which we'll also dig into, we'll work on optimising the issues we find. Whether it's a Python debugger, a Web Application or any other kind of Python development you're doing, you'll learn how to effectively profile and resolve many performance issues.

Miguel Sánchez de León Peque - Developing a real-time automated trading platform with Python [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/developing-a-real-time-automated-trading-platform-with-python) Nowadays Python is the perfect environment for developing a real-time automated trading tool. In this talk we will discuss the development of: a general-purpose multiagent-system module using Pyro and ZeroMQ; a platform, based on it, for developing automated trading strategies using Numpy, Numba, Theano, etc.; and a GUI for visualizing real-time market data using PyQtGraph and Qt. ----- In OpenSistemas we have developed a general-purpose multi-agent system which is written in pure Python: *osBrain*. Agents communicate with each other using ZeroMQ, allowing the user to define different communication patterns based on their needs. Based on this multi-agent system, we have also developed a broker- independent platform for real-time automated trading: *osMarkets*. This platform implements specialized agents: - **Feeder** is an agent which receives real-time data from the broker. - **Router** is an agent which receives data from feeders. It manages the historical data and distributes updates to all the subscribed agents in the network. - **Brain** is the most common agent. It receives data from router or from other brains and processes them, sending the results to other brains or sending orders to be executed. Brains can make use of many useful packages avilable in the Python ecosystem: NumPy, SciPy, Numba, Theano... - **Trader** is an agent which is designed to interact with the broker, just as the feeder, but to execute market orders.  While it is still in its earliest stages, we are developing a tool for real-time visualization of trading strategies using PyQtGraph. This tool acts as an agent in the multi-agent system. 

Adrian Dziubek - Python Descriptors for Better Data Structures [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/python-descriptors-for-better-data-structures) Have you ever wondered how Django models work? I'll present a story of data structure transformation. I will talk about ideas from Django models that I used and how I rediscovered descriptor API. I will talk about printing, serializing, comparing data structures and some other examples, where descriptors excel at making declarative code easier to write. ----- I worked as a developer of a testing framework for a C++ server. The framework tested binary protocol implemented by the server. Most of the work involved testers preparing test cases. The data format was primitive structures -- hard to read and easy to break. Field order and all the data had to be entered manually. At the time, I have already seen the better world -- the models from Django. Have you ever wondered how those work? Step by step, I used the ideas from there to make the structures more friendly and on my way I rediscovered descriptors. I'll show in incremental steps, how: - used keyword arguments to lower signal to noise ratio, - order of definition for sorting the fields, - realized that `__call__` is used instead of assignment, - used `__setattribute__` as first step to extend primitive fields, - discovered that I'm actually reimplementing descriptors, and how it lead me to: - implement printing in a way that is friendly to regression testing, - use diff library for less code and better results, - implement more readable validation. I want to show how descriptors work in Python and how they enable declarative style of programming. By the end of the talk I want you to understand what is at the core of the magic behind field types used by object relational mappers like Django.

Amber Brown - The Report Of Twisted’s Death [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/the-report-of-twisteds-death) This talk will teach you how Twisted or Tornado supplement asyncio, how asyncio can/is integrated with these frameworks, and makes a case for the continued development of new and existing selector-loop based frameworks. It will also paint a picture of the future direction of Twisted, why the original plan of asyncio as a standard API has not come to complete fruition, and what can be done about it. ----- Historically, there has been no “standard way” of doing asynchronous I/O in Python. A variety of solutions, from using threads (WSGI), processes (multiprocessing), green threads (gevent), or selector loops (Tornado, Twisted) have all been used to similar degrees, but apart from the (now deprecated) standard library asyncore/asynchat, Python itself did not have a blessed option. PEP 3156, or “the asyncio PEP”, introduced in Python 3.4, provides this blessed option, choosing a standard selector loop approach (or “reactor”, in Twisted parlance). The role of asyncio may seem muddled in the eyes of developers new to asynchronous programming, or those that may not understand the technical details of asyncio nor the political environment in which it was created. This talk will teach you how Twisted or Tornado supplement asyncio, how asyncio can/is integrated with these frameworks, and makes a case for the continued development of new and existing selector-loop based frameworks. It will also paint a picture of the future direction of Twisted, why the original plan of asyncio as a standard API has not come to complete fruition, and what can be done about it.

Roberto Polli - The Router Game [EuroPython 2016] [18 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/the-router-game) This interactive game teaches the basic of ip and ethernet protocol using just paper and pens, and become very popular with our interns and in our LUG meetings. Participants are divided in teams, simulating simple network infrastructures (eg. computers connected by an hub and a switch). ----- This interactive game teaches the basic of ip and ethernet protocol using just paper and pens, and become very popular with our interns and LUG meetings. Participants are divided in teams, simulating simple network infrastructures (eg. computers connected by an hub and a switch). Every player has a role: a PC or mobile phone, an HUB, a Switch, a Router, and must communicate with the others following the associate specification (eg. an hub should broadcast message to every neighbour, a switch should populate the mac address table, ...) The team which is faster in exchanging messages wins.

Mai Giménez - Un vector por tu palabra [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/un-vector-por-tu-palabra) El ecosistema científico de python es extraordinario y saca músculo con las últimas aportaciones de la comunidad científica. Revisaremos nuevas aproximaciones a la representación de texto. ¡Tus cadenas de texto merecen algo más que una mísera bolsa de palabras! Veremos cómo se aplica la representación distribuida (word embeddings) en un caso práctico de aprendizaje automático, y daremos consejos para hacer experimentos replicables y obtener datos significativos. ----- “Dime con quien andas y te diré cómo eres” Este dicho es una de las ideas más revolucionarias en PLN. Podemos saber muchas cosas de una palabra por su contexto. No es lo mismo un adorable gato que un gato mecánico, pero por el contexto diferenciamos esta palabra polisémica. Hasta ahora la mayor parte de los modelos representan una frase como una bolsa de palabras. Por ejemplo, si queremos representar este conjunto de frases: [“I love Python”, “I love NLP”, “Pyladies are cool”] tenemos un vocabulario de siete palabras: [“I”, “love”, “Python”, “NLP”, “Pyladies”, “are”, “cool”] esta representación crea un vector de tamaño del vocabulario para cada frase, y pone a 1 si la palabra aparece y a 0 en el caso contrario : [[1,1,1,0,0,0,0], [1,1,0,1,0,0,],[0,0,0,0,1,1,1]] ¡Pero,se pierde el contexto y los vectores pueden ser gigantes y con muchísimos 0s! Recientemente, hemos encontrado una forma mucho mejor de representar las palabras: La representación distribuida -word2vec, por ejemplo- En esta charla exploramos esta representación y cómo aplicarla en problemas de clasificación utilizando textos de redes sociales. Navegaremos por el rico ecosistema científico en python, veremos cómo crear gráficas significativas y hablaremos de la importancia de escribir experimentos bien diseñados, replicables y con código elegante y por supuesto de la importancia de difundir el conocimiento. Debemos inspirar a la siguiente generación de científicos y científicas ¡Seamos extraordinarios!

Jose Manuel Ortega - Hacking ético con herramientas Python [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/hacking-etico-con-herramientas-python) El objetivo de la charla sería mostrar las herramientas que disponemos dentro de la propia API de Python y librerías de terceros para desarrollar nuestras propias herramientas que permitan realizar pruebas de seguridad y de pentesting de las aplicaciones. ----- Python se ha convertido en el lenguaje más usado para desarrollar herramientas dentro del ámbito de la seguridad. Muchas de las herramientas que podemos encontrar hoy en día como escáner de puertos, análisis de vulnerabilidades, ataques por fuerza bruta y hacking de passwords, se han escrito en este lenguaje ,además de ofrecer un ecosistema de herramientas para realizar pruebas de seguridad y de pentesting de aplicaciones. Entre los puntos a tratar podríamos destacar: - **Introducir Python como lenguaje de desarrollo de herramientas de seguridad** - **Introducir librerías para obtener información de nuestro objetivo como Shodan,pygeocoder,pygeoip** - **Análisis y extracción de metadatos en Python en imágenes y documentos** - **Análisis de puertos con herramientas como python-nmap**

Cameron Macleod - Implementación de un Identificador de Sonido en Python [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/implementacion-de-un-identificador-de-sonido-en-python) El tema que nos ocupa es como implementar un identificador de sonido tipo Shazam usando técnicas DSP. Los puntos a seguir serán, implementación, retos y pasos adicionales. El proyecto que nos ocupa se encuentra todavía en proceso de desarrollo (el código [subido en GitHub][1]) y fue inspirado después la conferencia, [Over-the-Air Audio Identification][2] en FOSDEM 2016. [1]: https://github.com/notexactlyawe/abracadabra [2]: https://fosdem.org/2016/schedule/event/audio_identification/ ----- El tema que nos ocupa es como implementar un identificador de sonido tipo Shazam usando técnicas DSP con ayuda de unas fantásticas bibliotecas. Los puntos a seguir serán, implementación, retos y pasos adicionales. El proyecto que nos ocupa se encuentra todavía en proceso de desarrollo (el código [subido en GitHub][1]) y fue inspirado después la conferencia, [Over-the-Air Audio Identification][2] en FOSDEM 2016. La estructura básica del proyecto consiste en un clasificador y un reconocedor. El clasificador toma huellas del sonido y las procesa en una forma investigable para el reconocedor que usa estas huellas para la identificación y búsqueda de archivos almacenados con el fin de encontrar la semejanza mas probable. El reconocedor estará expuesto en un entorno API. La conferencia intentará introducir el área de DSP a la audiencia y los conceptos que están detrás aplicaciones como Shazam. Explicaré todos las nociones incluidas en una manera sencilla. [1]: https://github.com/notexactlyawe/abracadabra [2]: https://fosdem.org/2016/schedule/event/audio_identification/

Pau Ruŀlan Ferragut - Pytest desde las trincheras [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/pytest-desde-las-trincheras) Todo programador tiene interés para que su software sea fiable y estable. Haremos una sencilla introducción a pytest con el caso de uso de un site internacional para el que generamos cientos de tests y redujimos drásticamente los errores en producción. Con este simple ejemplo demostraremos que no siempre necesitamos hacer TDD para disfrutar de las ventajas de un framework de testing. ----- Las metodologías de desarrollo que incorporan la escritura de pruebas desde el momento cero tienden a generar código más estable y fiable pero la realidad es que muchas veces no gozamos del privilegio ni del presupuesto para escribir tests para todas las características de nuestro producto. Pero si tenemos a nuestra disposición herramientas de testing que nos permitan eliminar los errores evitables como romper enlaces en la página de inicio nos quitaremos el miedo a hacer pases a producción y generaremos más valor al negocio. La charla no tiene pretensión de ser ni una introducción al test driven development ni de las complejidades de qué es un buen o mal test. El objetivo es animar a todo aquel que todavía pruebe sus proyectos manualmente a intentar algún grado de automatización. Para ello la estructura será una presentación de pytest, exponer algunos plugins altamente recomendados y centrarse en el caso de uso de una página con presencia en ocho países donde automatizamos un montón de comprovaciones simples que nos permitieron reducir los errores evitables.

Moshe Goldstein/david dayan - Implementing Parallel Programming Design Patterns using EFL for Python [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/implementing-parallel-programming-design-patterns-using-efl-for-python) EFL (Embedded Flexible Language), a deterministic parallel programming tool, may be embedded in any host language. Two versions of the EFL pre-compiler for Python were implemented. One translates EFL blocks into Python's Multiprocessing code, and the other one into DTM/MPI4PY code. EFL implementations of Parallel Programming Design Patterns will be shown, generated parallel code compared, and differences discussed. Visit flexcomp.jct.ac.il for further information. ----- Multi-core CPUs are abundant and utilizing them effectively requires programmers to parallelize CPU-intensive code. To facilitate this, we have developed EFL (Embedded Flexible Language), a deterministic parallel programming tool. The parallel parts of a program are written as EFL-blocks, which are embedded into a sequential host language program. The sequential parts of the program are written in the host language, outside the EFL blocks. EFL may be embedded in any host language by writing an appropriate EFL pre-compiler. At the moment, we implemented two versions of the EFL pre-compiler. Both pre-compilers translate EFL blocks into parallel Python code - one of them generates parallel code based on Python's Multiprocessing module, and the other one generates parallel code based on the DTM/MPI4PY Python module. We will present the principles upon which EFL is built. We will show the implementation of Parallel Programming Design Patterns using EFL's parallel programming constructs (such as parallel assignments, parallel for-loops, etc.). Using our two EFL pre-compilers we will show their translation to Python parallel code according to the Multiprocessing module as well as the DTM/MPI4PY module. The differences between code versions produced by the EFL pre-compilers will be discussed. For further information about the EFL project and our Flexible Computation Research Laboratory, visit http://flexcomp.jct.ac.il

Victoria Martinez de la Cruz - Build your first OpenStack application with OpenStack PythonSDK [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/build-your-first-openstack-application-with-openstack-pythonsdk) Join this talk to learn about the OpenStack Python SDK and how to deploy your web app step by step using different components in OpenStack. ----- How many times you heard about OpenStack and all the cool things it is being used for? Most of the use cases are big players that need to handle huge amounts of data and automate complex infrastructures. But what about actually using it, for you as a developer, to deploy a simple app? In my case, at least, that has not be an usual topic of discussion when talking about OpenStack. In this talk I'll introduce the OpenStack Python SDK, a project relatively new in the OpenStack ecosystem, and show you step by step how to deploy your own web app using different components in OpenStack.

Elena Cuoco - Python in Gravitational Waves Research Communities [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/pyhton-in-gravitational-waves-research-communities) On February 11th 2016 Ligo-Virgo collaboration gave the announce of the discovery of Gravitational Waves, just 100 years after the Einstein’s paper on their prediction. A brief introdutcion to data analysis methods used in Gravitational Waves (GW) communities Python notebook describing how to analyze the GW event detected on 14 September 2015. ----- On February 11th 2016 Ligo-Virgo collaboration gave the announce of the discovery of Gravitational Waves, just 100 years after the Einstein’s paper on their prediction. After an introduction on Gravitational Waves, on Virgo Interferometric detector, I will go through the data analysis methods used in Gravitational Waves (GW) communities either for the detector characterization and data condition or for the signal detection pipelines, showing the use of python we make. As practical example I will introduce a python notebook describing the GW event detected on 14 September 2015 and I will show a few of signal processing techniques.

Francisco Igual - MiniBrew: Brewing beer with Python [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/minibrew-brewing-beer-with-python) Dutch startup MiniBrew intends to disrupt the beer market by introducing an easy-to-use beer brewing machine controlled by a mobile app and communicating with a Python backend. Users want real-time insights in their brewing process, which presented some challenges in terms of architectural design. In this talk Elements Interactive's Chesco discusses best practices and pitfalls of the IoT architecture of MiniBrew by diving into message queues, protocol buffers and full- session logging. ----- The number one alcoholic drink in the world is undoubtedly beer. With the rise of craft beers, also homebrewing has become very popular in recent years, although it is still a complex and expensive hobby. Dutch startup MiniBrew intends to change that with their revolutionary beer brewing machine, which is controlled by a mobile app and communicates with a Python API backend. In this talk Chesco will share his ideas and experiences in utilizing Python in the backend architecture for the MiniBrew project he and his team are working on at MiniBrew's development partner Elements Interactive. As many IoT projects, the ingredients for MiniBrew are a device with a limited chipset and internet connection, a backend to store the data acting as the mastermind and a mobile app to allow end users to control the brewing process. The fact that we want users to know in real-time how their beer brewing process is doing presented some challenges which required us to come up with a competitive architecture that would both give real- time status updates and not saturate the server with continuous calls. Chesco discusses best practices and pitfalls in designing and developing IoT architecture by diving into the RabbitMQ message broker, the MQTT protocol and protocol buffers. He will focus on the REST API and CMS site written in Python, elaborating on high frequency data in the apps, scalability, full-session logging and overcoming common architectural challenges.

Scott Reeve - Keeping the Lights on with Python [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/keeping-the-lights-on-with-python) We are using Python to help the National Grid in the UK to balance electricity production and usage. We do this by installing Python powered devices at customers sites that allow us to monitor and set control criteria to automatically turn on and off power consuming and producing devices when there is a mismatch between electricity supply and demand. In this talk we will be talking about how and why we have used Python, as well as where in our system we would like to use Python. ----- We are using Python to help the National Grid in the UK to balance electricity production and usage. We do this by installing Python powered devices at customers sites that allow us to monitor and set control criteria to automatically turn on and off power consuming and producing devices when there is a mismatch between electricity supply and demand. These devices talk to our Python powered cloud based system using the 3g network, giving us near real-time monitoring of our customers assets. Our entire infrastructure is written in Python, from our billing systems, data analytics systems and customer portal all the way through to our on site industrial system interfaces. In this talk we will be talking about how and why we have used Python, where we have had problems, as well as where in our system we would like to use Python and why we cannot. We will also be talking about what we are going to do next, moving our system from near real time monitoring to near real-time control, using Python for both system modelling and control. We will discuss how we are using Python to creating a system that monitors the balance between electricity supply and demand many times per second and is able to provide a corrective control based on the sum of the output of a dynamic set of our customer sites and the challenges that presents.

Max Tepkeev - Do I need to switch to Go(lang) ? [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/do-i-need-to-switch-to-golang) Nowadays, there is a lot of buzz about Go. In this talk we'll learn the basics and most important concepts of the language, we'll further discuss differences and similarities in Go and Python and dive into the cool features of Go. Finally we'll talk about why popularity of Go is raising so fast and try to answer the most important question: Do I need to switch to Go ? ----- Nowadays, there is a lot of buzz about Go. It happened so that for the last 6 months I've been mostly programming Go, and frankly speaking I fell in love with this language. We'll first do a quick review of the language. Go doesn't have some language constructs, for example classes and exceptions and at first it may seem hard to write proper Go code, but in practice the language is so easy that I will try to teach you the basics and most important concepts of the language. We'll further discuss differences and similarities in Go and Python and dive into the cool features of Go. Finally we'll talk about why popularity of Go is raising so fast and try to answer the most important question: Do I need to switch to Go ?

Iwan Gulenko - How to make IT-recruiting suck less. [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/coding-interviews-what-to-expect-and-how-to-prepare) I am a programmer and I am on a mission to make IT-recruiting suck less. This talk should be useful for both hiring managers and job-seekers. We will assess the status-quo of hiring engineers and talk about resumes, coding questions and tasks that firms make up to assess engineers. Also, we'll discuss salary negotiation best-practises from a candidate perspective. We end with a discussion on different "types" of programmers (http://blog.triplebyte.com/who-y-combinator-companies-want).

Peter Hoffmann - SQLAlchemy as the backbone of a Data Science company [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/sqlalchemy-as-the-backbone-of-a-data-science-company) In times of NoSQL databases and Map Reduce Algorithms it's surprising how far you can scale the relational data model. At [Blue Yonder](http://blue- yonder.com) we use SQLAlchemy in all stages of our data science workflows and handle tenth of billions of records to feed our predictive algorithms. This talk will dive into SQLAlchemy beyond the Object Relational Mapping (ORM) parts and conentrate on the SQLAlchemy Core API, the Expression Language and Database Migrations with Alembic. ----- In times of NoSQL databases and Map Reduce Algorithms it's surprising how far you can scale the relational data model. At [Blue Yonder](http://blue- yonder.com) we use SQLAlchemy in all stages of our data science workflows and handle tenth of billions of records to feed our predictive algorithms. This talk will dive into SQLAlchemy beyond the Object Relational Mapping (ORM) parts and conentrate on the SQLAlchemy Core API and the Expression Language: - **Database Abstraction**: Statements are generated properly for different database vendor and type without you having to think about it. - **Security**: Database input is escaped and sanitized prior to beeing commited to the database. This prevents against common SQL injection attacks. - **Composability and Reuse**: Common building blocks of queries are expressed as SQLAlchemy selectables and can be reuesd in other queries. - **Testability**: SQLAlchemy allows you to perform functional tests against a database or mock out queries and connections. - **Reflection**: Reflection is a technique that allows you to generate a SQLAlchemy repesentation from an existing database. You can reflect tables, views, indexes, and foreign keys. As a result of the usage of SQLAlchemy in Blue Yonder, we have implemented and open sourced a SQLAlchemy dialect for the in memory, column-oriented database system [EXASolution](https://github.com/blue-yonder/sqlalchemy_exasol)

Iker Martinez de Agirre Mendia - Datu bistaratze soluzioen garapena Smartcity proiektuetan [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/datu-bistaratze-soluzioen-garapena-smartcity-proiektuetan-1) Laburbilduz, kontsumo energetikoaren datuak modu sinple eta argi batean bistaratzen dituen web orrialde bat sortu da Django erabiliz. ----- Mondragon Unibertsitateko inbestigazio taldea Smartcity-en aplikazio eta monitorizazioen inguruko proiektuetan lanean ari da, non herrialde ezberdinetako gune konkretuetan bizi diren pertsonen kontsumo energetikoa jaso eta aztertzen den. Proiektu hauetako bi CITyFiED eta ARROWHEAD dira. Kontsumo hori eta horren harira ondorioztatutako aholku energetikoak erabiltzailearengana heltzeko, bistaratze soluzio bat garatu da, web orrialde bat alegia. Erabiltzailean oinarritutako diseinua (User Centered Design) aplikatuz, gailu ezberdinetara moldatzen den (Responsive Web Design, Mobile-First) web bat sortu da, Django Web Framework tresnaren bitartez. REST API (Django Rest Framework) baten bidez, informazioa gordetzen den datu basea atzitzen da, kontsumoak eta beraien bilakaera bistaratze libreriak (D3.js) erabiliz irudikatuz. Horrez gain, Djangok eskaintzen dituen aukerak baliatuz, web orrialdea hizkuntza ezberdinetan bistaratu daiteke. Laburbilduz, kontsumo energetikoaren datuak modu sinple eta argi batean bistaratzen dituen web orrialde bat sortu da Django erabiliz."

Mikel Larreategi - EITB Nahieran: askatu bideoak API honen bidez [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/eitb-nahieran-askatu-bideoak-api-honen-bidez) EITB Nahieran zerbitzuaren informazioa era erabilgarrian erakusteko APIaren nondik norakoak erakutsiko ditut hitzaldian. ----- Iaz Raspberry PI bat erosi nuen eta ez nekien zer egin berarekin... Aurten Kodi softwarea erabiliz media-center bihurtu dut Raspberrya. Kodirako 'tvalacarta' izeneko plugin bat zegoen berarekin EITB Nahieran ikusteko, baina ez zebilen. Saiatu nintzen EITB Nahieranen kodea funtzionarazten, eta asko kostata informazioa hiru era ezberdinetan ateratzea lortu nuen. Azkenean, funtzionamendua errazteko API bat prestatu dut EITB Nahieranen dagoen informazioa atzitzeko eta edozeinek erabili ahal dezan. [Aurkezpena][1] eta [aurkeztutako kodea][2] [1]: https://erral.github.io/eitbapi [2]: https://github.com/erral/eitbapi

Jatsu Argarate - Buildout Django eta Fabric. Kasu praktikoa euskarazko tokiko hedabideetan [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/buildout-django-eta-fabric-kasu-praktikoa-euskarazko-tokiko-hedabideetan) Hainbat zerbitzaritan dauden eta plataforma bakar batean oinarrituta dagoen plataforma baten mantentzea Buildout Django Fabric eta erabiliz. Kasu praktikoa euskarazko tokiko hedabideak. ----- Hainbat bezerorentzako neurrira egindako edukiak kudeatzeko plataforma bat garatu dugu Django Frameworka erabiliz. Guztia kudeatzeko eta erabilitako bertsioak kontrolatzeko zc.buildout erabiltzen dugu, baina plataforma hazten doa eta iada dozena bat instalazio ditugu hainbat zerbitzaritan zehar banatuta. Plataformaren oinarria berbera denez, instalazio guztietan eguneraketak argitaratzeko buildout eta fabric-en oinarritutako sistema erabiltzen dugu. Hitzaldi honetan azalduko duguna.

Stephan Jaensch - Building Service interfaces with OpenAPI / Swagger [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/building-service-interfaces-using-OpenAPI) Ever wondered how to keep track of all of your services and their APIs? I'm going to explore how to build your Python services with OpenAPI/Swagger and how it helps you solve problems like communication between services, request and response validation, and documentation of your API. I'll also discuss some challenges you might face when running Swagger in production, gathered from over a year of heavy usage at Yelp. ----- Implementing a service-oriented architecture (SOA) is a proven way to split up large monolithic codebases and to scale development when your organization grows to hundreds or thousands of engineers. I'm going to explore how to build and document your services with OpenAPI (formerly known as Swagger). I’ll discuss the benefits, how to generate a beautiful HTML documentation for your API, and how you can effortlessly make calls to your services. In the second part of the talk I'll discuss and tell you how to overcome challenges you might face when running OpenAPI in production, gathered from over a year of heavy usage at Yelp for hundreds of services. The OpenAPI initiative is a cross-vendor consortium focused on creating, evolving and promoting a vendor neutral description format. As an open governance structure under the Linux Foundation, its members include Google, IBM, Atlassian and PayPal.

L. Ozaeta - Endor, ipuinak kontatzen zituen Nao robota. [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/endor-ipuinak-kontatzen-zituen-nao-robota) Aurkezpen honetan Nao robotaren Choreographe programazio ingurumenaren sarrera bat egiten da, pythonek errobotikan duen erabilpena erakutsiz. Aurkezpen guztia aurkezleak orain arte egindako lanean oinarritzen da. Lehenik eta behin, programa baten estruktura erakutsiko da. Ondoren, liburutegi bat nola gehitu erakutsiko da, liburutegiaren instalazioak ekar ditzakeen arazoak aztertuz. Azkenik, Naoaren gorputz jarreran zein diskurtsoaren naturaltasunean egindako aurrerapenak azalduko dira. ----- Honekin lortu nahi diren helburuak honako hauek dira: - Choreographeko proiektu baten estruktura ezagutzea. - Nao robot baten oinarrizko programa bat ikustea. - Chorepgraphek ematen dituen programazio blokeak eraldatzen jakitea, python erabiliz. - Choreographen eskaintzen diren tresnen bitartez, programan python liburutegi bat gehitzen ikastea. Aurkezpen hau ulertzeko ez dago eskakizunik. Python pixka bat dakien edonork (“hello world” bat egiten jakitearekin balio du) ulertzeko mailan emango da eta ez da konplexutasun tekniko handiko azalpenik emango. Printzipioz python ezagutzen ez duen edonor ere aurkezpen ia osoa ulertzeko gai izango da, programazio ingurumen bezala ez baita kodean gehiegi sartzen, pythonekin hasteko aukera ona izanez.

Anjana Vakil - Exploring Python Bytecode [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/exploring-python-bytecode) Do you ever wonder how your Python code looks to the interpreter? What those `.pyc` files are? Why one program outperforms another, even if the code is similar? Then let’s dive into Python bytecode! Bytecode is the "intermediate language" that expresses your source code as machine instructions the interpreter can understand. In this talk we’ll see what role it plays in executing Python programs, learn to read it with the `dis` module, and analyze it to better understand a program’s performance. ----- Do you ever wonder what your simple, beautiful Python code looks like to the interpreter? Are you starting to get curious about those `.pyc` files that always pop up in your project, and you always ignore? Would you like to start investigating your Python code's performance, and learn why some programs you write run faster than others, even if the code looks more or less the same? Have you simply fallen so completely in love with Python that you're ready to peer deep inside its soul? If you, like me, answered "yes" to any of these questions, join me in an illuminating adventure into the world of Python bytecode! Bytecode is the "intermediate language" that expresses your Python source code as machine instructions the interpreter (specifically CPython, the "standard" interpreter) can understand. Together we'll investigate what that means, and what role bytecode plays in the execution of a Python program. We'll discover how we simple humans can read this machine language using the `dis` module, and inspect the bytecode for some simple programs. We'll learn the meaning of a few instructions that often appear in our bytecode, and we'll find out how to learn the rest. Finally, we'll use bytecode to understand why a piece of Python code runs faster if we put it inside of a function. When you go home, you'll be able to use bytecode to get a deeper understanding of your Python code and its performance. The adventure simply starts here; where it ends is up to you!

Andreas Klostermann - Brainwaves for Hackers 3.0 [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/brainwaves-for-hackers-3) This talk is about using our **Python** skills to explore the **secrets of our brains**. Using the Neurosky Mindwave as a bluetooth connected EEG device, I'll talk about new experiments I have performed inside the Jupyter notebook, for example "Evoked Response Potentials" and more about "Neuro Feedback" training. ----- Electroencephalography **(EEG)** measures potential waves originating within the brain. Billions of brain cells fire inside your brain, each sending out a minuscule wave. The summed potential waves can be measured, even with quite cheap and **portable devices**. Being the third major version of this talk, I'll talk briefly about the Neurosky Mindwave and the Muse headset. I have also developed more interactive Jupyter experiments, which I'll demonstrate in the talk. For example **Evoked Response Potentials (ERP)** can be demonstrated with relatively simple means. Also I'll talk some more about experiments with **Neuro Feedback**.

Christie Wilson/Michael Tom-Wing - System Testing with pytest and docker-py [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/system-testing-with-pytest-and-docker-py) System tests are an invaluable tool for verifying correctness of large scale online services. This talk will discuss best practices and tooling (pytest and docker-py) for writing maintainable system tests. Demonware has used System tests to verify online services for some of the biggest AAA video game launches as well as internal operational tools. Many folks who write software are familiar with unit testing, but far fewer with system testing. ----- System testing a microservice architecture is challenging. As we move away from monolithic architectures, system testing becomes more important but also more complicated. In the video game industry, if a game doesn’t work properly immediately after launch, it will heavily impact game success. We have found system testing to be an important tool for pre launch testing of game services and operational tools, to guarantee quality of these services at launch. We want to share with you best practices for system testing: when to write system tests, what to test and what not to, and common pitfalls to avoid. Using python’s pytest tool and docker-py for setting up services and their dependencies has made it easier than ever to write complex but maintainable system tests and we’ll share with you how we’ve made use of them. Developers (senior and junior) and ops folks can walk away from this talk with practical tips they can use to apply system testing to their software.

Mariano Anaya - Clean code in Python [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/clean-code-in-python) Introduction to the clean code principles applied to Python code. Let's honor the readable nature of the Python syntax so anyone can maintain our code: "readability counts". This talk introduces general concepts of code quality and how they apply for Python. We analyse technical debt, refactoring, and unit testing in the context of a project striving for a better code base. ----- Introduction to the clean code principles tailored for Python projects. The goal is to achieve better code quality and a more maintainable code base. Python has a nature of being clear, and easy to follow, so let's take advantage of it in our own code, in order to enforce the principle "readability counts" by writing pythonic code. This talk introduces general concepts of code quality for Python developers, analyzing technical debt, with examples on how to achieve a more legible, maintainable and clean code base, by refactoring, writing unit tests and having good coding guidelines for the project. If you are giving your first steps with Python, you will gain insight on best practices for writing good software from the start. If you are a experienced developer, the ideas should work as food for thought, helping with recommendations for code reviews, best practices, etc.

Fernando Masanori Ashikaga/Paola Katherine Pacheco/Kátia Nakamura - import community [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/import-community) One of the biggest differences, in the Python community, is its effort to improve diversity. The authors will share experiences on diversity obtained from ten different countries: Namibia, UK, Japan, Brazil, Italy, Argentina, Uruguay, Germany, Canada and Spain. There are other reports, that also we would like to share, which are only beautiful stories of how Python reaches the most distant people and places you may never have imagined. ----- One of the biggest differences, in the Python community, in relation to other communities, is its effort to improve diversity. There is even a Diversity Statement at PSF: "We have created this diversity statement because we believe that a diverse Python community is stronger and more vibrant. A diverse community where people treat each other with respect has more potential contributors and more sources for ideas." The authors will share experiences on diversity obtained from ten different countries: Namibia, UK, Japan, Brazil, Italy, Argentina, Uruguay, Germany, Canada and Spain. There are other reports that we also would like to share, which are only beautiful stories of how Python reaches the most distant people and places you may never have imagined.

Alex Vinyals - Ingesting 35 million hotel images with python in the cloud. [EuroPython 2016] [19 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/ingesting-35-million-hotel-images-with-python-in-the-cloud) This talk covers the distributed architecture that Skyscanner built to solve the data challenges involved in the generation of images of all hotels in the world. Putting together a distributed system in Python, based on queues, surfing on the AWS Cloud. ----- Our goal? To build an incremental image processing pipeline that discards poor quality and duplicated images, scaling the final images to several sizes to optimise for mobile devices. Among the challenges: 1. Ingest all the input images that partners provide us. 2. Detect and remove bad quality + duplicated images from reaching production. 3. Resize all the generated images to optimise for mobile devices. 4. Ensure the process scales and behaves in an incremental way. 5. Ensure the whole process fits in a time constrained window. Among the tools we used? Pillow, ImageHash, Kombu and Boto.

Michał Karzyński - Building beautiful RESTful APIs using Flask [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/building-beautiful-restful-apis-using-flask-1) This talk demonstrates a technique for developing RESTful APIs using Flask and Flask-Restplus. These tools automate common API tasks such as: validating input, serializing output, routing requests to methods, and turning Python exceptions into HTTP responses. The final API comes with a Swagger interactive UI, which documents all endpoints and makes testing easy. The described tools tools provide just enough syntactic sugar to make your code readable, scalable and easy to maintain. ----- Modern software is powered by APIs. User facing apps may run in the browser or on mobile platforms, but they almost universally rely on data stored in the cloud. More often then not apps use a RESTful API to exchange data with the server. In my talk I will demonstrate a technique for developing RESTful APIs using the [Flask][1] micro-framework and [Flask-Restplus][2]. These powerful tools automate most common tasks associated with API development: validating input, serializing output, routing requests to methods, and turning Python exceptions into machine-readable HTTP responses. A Flask-Restplus API is fully documented by [Swagger][3] which lists all defined endpoints, their query parameters and the format of input and output JSON objects. Swagger generates an [interactive UI][4] for selecting options and easily testing queries. Flask and Flask-Restplus provide just enough syntactic sugar to make your code readable, scalable and easy to maintain. My presentation will give an overview of the features of Flask and Flask-Restplus; I will describe how easy it is to get started and discuss some best practices for building complex APIs using this approach. I will wrap up by briefly mentioning other components of the Flask ecosystem, which give this micro-framework power to match fully- loaded systems such as Django. [1]: http://flask.pocoo.org/ [2]: http://flask-restplus.readthedocs.org/en/latest/ [3]: http://swagger.io/ [4]: http://petstore.swagger.io/#/pet

Malwina Nowakowska - RESTful API - Best Practices. [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/restful-api-best-practises) It is important to understand from the beginning how model API should look like. Do not repeat your friends’ mistakes and make developers upset! There are some simple rules that can make your API cooler - clean, safe and efficient. Based on both bad and good examples of REST APIs (I had to deal with) we will learn about best practices. ----- Nowadays building and integrating with Representational State Transfer web services is a very common thing. It seems that creating RESTful API is trivial - nothing could be more wrong. In my previous projects I had to integrate with lots of APIs. Unfortunately only some of them were easy to work with. Most of the APIs did not follow the main rules of model API. It is really important to understand how model REST API should look like. To make developers happy we will learn best practices of creating REST API from the beginning. We will start with quick introduction what REST is, why principle of REST is so amazing, talk about identifires and explain some key terms. We will discuss about architectall constraints and properties. Mistakes and best practices are based on my experience of developing and maintaining the projects. After this talk you will be able to create model RESTful API developers will be happy to work with.

Andrew Burrows - Testing the untestable: a beginner’s guide to mock objects [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/testing-the-untestable-a-beginners-guide-to-mock-objects) In this session you will learn your way around Python 3’s unittest.mock package through examples. You’ll learn about the Mock class, sentinels and patching. You will see the benefits that mocks can bring and learn to avoid the pitfalls. Along the way I’ll fill you in on some of the bewildering terminology surrounding mocks such as “SUT”, “Stub”, “Double”, “Dummy” , “mockist” and more and I’ll give a brief plug for my own mockextras package that can enhance your mock experience. ----- Mock objects can be a powerful tool to write easy, reliable tests for the most difficult to test code. In this session you will learn your way around Python 3’s unittest.mock package starting at the simplest examples and working through progressively more problematic code. You’ll learn about the Mock class, sentinels and patching and how and when to use each of them. You will see the benefits that mocks can bring and learn to avoid the pitfalls. Along the way I’ll fill you in on some of the bewildering terminology surrounding mocks such as “SUT”, “Stub”, “Double”, “Dummy” , “mockist” and more and I’ll give a brief plug for my own mockextras package that can enhance your mock experience.

Elizaveta Shashkova - Monkey-patching: a magic trick or a powerful tool? [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/monkey-patching-a-magic-trick-or-a-powerful-tool) Monkey-patching is a dynamic modification of a class or a module at runtime. The Python gives developers a great opportunity to use monkey-patching almost everywhere. But should developers do it? Is it a magic trick or a powerful tool? In this talk we will try to give the answers to these questions and try to figure out pros and cons of using monkey- patching. ----- First of all we will learn what is monkey-patching in Python and consider some basic examples of using it. Of course, monkey-patching may cause some problems in the code. We will consider bad ways to use it and try to learn different types of problems monkey-patching may lead to. Despite of some bugs that may appear in a patched program, monkey- patching is used in a real life rather often. There are some reasons and motives to do it. We will consider the examples of using monkey- patching in real projects like `gevent`, in some other libraries and in testing. Also we will learn some monkey-patch tricks that helps to solve real-life problems in the Python debugger which is a part of the PyCharm and the PyDev. After that we will compare using of monkey-patching in Python to using it in an another dynamic language Ruby. Are there any differences between them? Is our reasoning correct for Ruby? Finally we will conclude all our thoughts and examples and try to give the answer to the question from title.

John Sutherland - Iteration, iteration, iteration [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/iteration-iteration-iteration) There should be something for everyone in this whistle–stop tour of iteration in Python setting off from `for`–loops, and riding cross–country to multiplexing coroutines! See and hear the amazing sights and sounds of list comprehensions, and generators. Take in the amazing vistas from `itertools`, and be amazed at the magnificent `yield`! ----- We’ll take detours to higher–order functions, closures, and decorators. And cover the FP inspired builtins `map`, `filter`, and `reduce`, as well as the epitome of Pythonic programming, `enumerate`.

Hynek Schlawack - Get Instrumented! [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/get-instrumented) To get real time insight into your running applications you need to instrument them and collect metrics: count events, measure times, expose numbers. Sadly this important aspect of development was a patchwork of half-integrated solutions for years. Prometheus changed that and this talk will walk you through instrumenting your apps and servers, building dashboards, and monitoring using metrics. ----- Metrics are highly superior to logging in regards of understanding the past, presence, and future of your applications and systems. They are cheap to gather (just increment a number!) but setting up a metrics system to collect and store them is a major task. You may have heard of statsd, Riemann, Graphite, InfluxDB, or OpenTSB. They all look promising but on a closer look it’s apparent that some of those solutions are straight-out flawed and others are hard to integrate with each other or even to get up and running. Then came Prometheus and gave us independence of UDP, no complex math in your application, multi-dimensional data by adding labels to values (no more server names in your metric names!), baked in monitoring capabilities, integration with many common systems, and official clients for all major programming languages. In short: a *unified* way to gather, process, and present metrics. This talk will: 1. explain why you want to collect metrics, 1. give an overview of the problems with existing solutions, 1. try to convince you that Prometheus may be what you’ve been waiting for, 1. teach how to impress your co-workers with beautiful graphs and intelligent monitoring by putting a fully instrumented Python application into production, 1. and finally give you pointers on how to migrate an existing metrics infrastructure to Prometheus *or* how to integrate Prometheus therein.

Florian Wilhelm - Handling GPS Data with Python [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/handling-gps-data-with-python) If you have ever happened to need to deal with GPS data in Python you may have felt a bit lost. This talk presents libraries starting from basic reading and writing GPS tracks in the GPS Exchange Format to adding missing elevation information. Also visualisation of tracks on OpenStreetmap data with interactive plots in Jupyter notebooks is covered. Additionally common algorithms for GPS like Douglas-Peucker and Kalman filter are explained. ----- If you have ever happened to need to deal with GPS data in Python you may have felt a bit lost. There are many libraries at various states of maturity and scope. Finding a place to start and to actually work with the GPS data might not be as easy and obvious as you might expect from other Python domains. Inspired from my own experiences of dealing with GPS data in Python, I want to give an overview of some useful libraries. From basic reading and writing GPS tracks in the GPS Exchange Format with the help of gpxpy to adding missing elevation information with srtm.py. Additionally, I will cover mapping and visualising tracks on OpenStreetmap with mplleaflet that even supports interactive plots in a Jupyter notebook. Besides the tooling, I will also demonstrate and explain common algorithms like Douglas-Peucker to simplify a track and the famous Kalman filters for smoothing. For both algorithms I will give an intuition about how they work as well as their basic mathematical concepts. Especially the Kalman filter that is used for all kinds of sensor, not only GPS, has the reputation of being hard to understand. Still, its concept is really easy and quite comprehensible as I will also demonstrate by presenting an implementation in Python with the help of Numpy and Scipy. My presentation will make heavy use of the Jupyter notebook which is a wonderful tool perfectly suited for experimenting and learning.

Anna Herlihy - Wrestling Python into LLVM Intermediate Representation [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/wrestling-python-into-llvm-intermediate-representation) The LLVM Project provides an intermediate representation (LLVM-IR) that can be compiled on many platforms. LLVM-IR is used by analytical frameworks to achieve language and platform independence. What if we could add Python to the long list of languages that can be translated to LLVM-IR? This talk will go through the steps of wrestling Python into LLVM-IR with a simple, static one-pass compiler. ----- What is LLVM-IR? The LLVM Compiler Infrastructure Project provides a transportable intermediate representation (LLVM-IR) that can be compiled and linked into multiple types of assembly code. What is great about LLVM-IR is that you can take any language and distill it into a form that can be run on many different machines. Once the code gets into IR it doesn’t matter what platform it was originally written on, and it doesn’t matter that Python can be slow. It doesn’t matter if you have weird CPUs - if they’re supported by LLVM it will run. What is Tupleware? TupleWare is an analytical framework built at Brown University that allows users to compile functions into distributed programs that are automatically deployed. TupleWare is unique because it uses LLVM-IR to be language and platform independent. What is PyLLVM? This is the heart of the talk. PyLLVM is a simple, easy to extend, one-pass static compiler that takes in the subset of Python most likely to be used by Tupleware. PyLLVM is based on an existing project called py2llvm that was abandoned around 2011. This talk will go through some basic compiler design and talk about how some LLVM-IR features make our lives easier, and some much harder. It will cover types, scoping, memory management, and other implementation details. To conclude, it will compare PyLLVM to Numba, a Python-to-LLVM compiler from Continuum Analytics and touch on what the future has in store for PyLLVM.

Claudia Guirao Fernández - Python, Data & Rock'n'Roll [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/python-data-rocknroll) Approach to topics, evolution, correlations through the lyrics of some of the greatests rock bands of all times. We will talk about the different phases of this personal project, in which I approach to a passion through a scientific method. This is a project that combine different techniques: - web crawling - NoSQL - Natural Language Processing - Data visualization ----- Have you ever wonder how David Bowie has evolved into the theme of his songs throughout their studio albums? Want to find out in what looks like Nirvana and Pink Floyd? Approach to topics, evolution, correlations through the lyrics of some of the greatests rock bands of all times. We will talk about the different phases of this personal project, in which I approach to a passion through a scientific method. This is a project that combine different techniques: - Web crawling - NoSQL - Natural Language Processing - Data visualization

Ian Lewis - Deep Learning with Python & TensorFlow [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/deep-learning-with-python-tensorflow) Python has lots of scientific, data analysis, and machine learning libraries. But there are many problems when starting out on a machine learning project. Which library do you use? How do they compare to each other? How can you use a model that has been trained in your production app? In this talk I will discuss how you can use TensorFlow to create Deep Learning applications. I will discuss how it compares to other Python machine learning libraries, and how to deploy into production. ----- Python has lots of scientific, data analysis, and machine learning libraries. But there are many problems when starting out on a machine learning project. Which library do you use? How do they compare to each other? How can you use a model that has been trained in your production application? TensorFlow is a new Open-Source framework created at Google for building Deep Learning applications. Tensorflow allows you to construct easy to understand data flow graphs in Python which form a mathematical and logical pipeline. Creating data flow graphs allow easier visualization of complicated algorithms as well as running the training operations over multiple hardware GPUs in parallel. In this talk I will discuss how you can use TensorFlow to create Deep Learning applications. I will discuss how it compares to other Python machine learning libraries like Theano or Chainer. Finally, I will discuss how trained TensorFlow models could be deployed into a production system using TensorFlow Serve.

Mike BRIGHT - Jupyter for everything else [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/jupyter-for-everything-else) Sure you can do a chunk of scientific exploration and stuff in Jupyter in your choice of language supplemented with visuals and that's already awesome ! But let's head off the beaten track a little to look at other uses, especially command-line. We'll look at some alternate uses of Jupyter ... ----- - Write command-line tutorials, cheat sheets in an easy to maintain format. - Perform visualization tasks for command-line tools - Write blog posts - Create interactive presentations (thanks Damian !) - Publish interactive books, articles and blog posts - HTML/js/css experimentation

Tobias Oberstein - Scaling Microservices with Crossbar.io [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/scaling-microservices-with-crossbario) Microservices offer an efficient way to only scale those parts of your application which are performance bottlenecks. We will demo and explain open source tech which allows the easy scaling out across distributed devices. The audience will be able to donate processor cycles from their devices to our demo application (and win a hardware prize). The demo uses [Crossbar.io][1], an open souce application router (written in Python), and all demo code is open source. [1]: http://crossbar.io ----- Microservices offer an efficient way to only scale parts of your applications which are hotspots. Instead of running multiple instances of a monolithic application, with all the complexity and operational run-time overhead that entails, you can scale only the functionality which is a bottleneck. Today that increasingly means scaling out, not up. We will go over open source technologies which allow the easy scaling out across distributed devices. A live demo will allow the audience to participate with its devices (including mobile phones) in an application. (There will be prizes for the donors.) The demo uses [Crossbar.io,][1] an open source router for the open [Web Application Messaging Protocol (WAMP) ][2] written in Python. WAMP supports routed Remote Procedure Calls, and Crossbar.io uses these to implement various load-balancing strategies across endpoints which register a particular procedure. WAMP has a first-class library for Python ([Autobahn|Python][3]), but is cross-language, with support for a total of 11 languages. This allows you to implement polyglot and heterogenos microservices applications, from Python to Node.js to C# right into the browser. Microservices can run anywhere, since the outgoing connections to the router which WAMP uses avoid NAT problems. All software used is open source, and all demo code is provided on GitHub under the MIT license. [1]: http://crossbar.io [2]: http://wamp-proto.org [3]: http://autobahn.ws/python

Michał Bultrowicz - TDD of Python microservices [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/tdd-of-python-microservices) A framework-agnostic approach to creating Python microservices with a tests-first approach. I'll show how to utilize Docker and Swagger to create service and contract tests that run your service as an independent process, as if it was running in production, giving you and your team a higher degree of confidence when introducing changes. A little bit of a broader microservice, TDD and work management context will also be given. ----- These will be my ideas on how to help a microservice-based (HTTP) project by integrating testing into the development process (TDD). I'll approach the testing pyramid presented in Martin Fowler's "Microservice Testing" as well as the test variants in "Building Microservices" (O'Reilly) and I'll show a way of how they can be translated to real-life Python. The main focus will be on "service tests" (aka. out-of-process component tests) and contract tests. They both can be run relatively fast on a development machine and can give fast feedback to the developer, preventing many kinds of problems. Service tests run the whole application process without any internal modifications, but have to present the service with a fake "outside world". I'll show how to fake external HTTP services with Mountebank (similar to WireMock). Instead of faking other systems (like databases) we can quickly spin up the real deal as a Docker container from within the tests. Contract tests check if the contract (interface) of your service with the outside world is kept, so no external services should be broken by the changes you are introducing. It can also work the other way around, proving that your collaborators are keeping their part of the deal. In both cases, Swagger (a RESTful API description scheme) and a few clever tricks can be used for significant advantage.

Joaquin Berenguer - Server for IoT devices and Mobile devices using Wifi Network, [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/server-for-iot-devices-and-mobile-devices-using-wifi-network) The server is developed in Python 3.4, using MySQL5.6 The mobile device application is developed using Kivy. The application in the IoT device is developed in C. The IoT device is a hardware device using ATSAMD21 from Atmel, and wifi is made using ESP8266. The security used is sha256, standard in Python. And the IoT device using the crypto device ATECC508A, that generate also sha256. ----- The server is developed in Python 3.4, the information is stored in a MySQL 5.6 database. All IoT devices, Mobile Devices and Windows or Linux Desktop are registered in the database. All type of messages that are understood by every type of device, is also registered. A map between which device could access which device is also stored in the database. With this info, any mobile registered could send a message to a device. The message arrives to the server that resend the message to the IoT device, receive the answer and resend to the Mobile device. The Mobile device and the IoT device, could be anywhere, as the server is public, have the registration of every device connected. The mobile device application is developed using Kivy. The application in the IoT device is developed in C. The IoT device is a hardware device using ATSAMD21 from Atmel, and wifi is made using ESP8266. The security used is sha256, standard in Python. And the IoT device using the crypto device ATECC508A, that generate also sha256. The server start a thread for every device connected, the communication between thread is made using queues. During the presentation, the server is going to be presented, and IoT device is shown, no demo is going to be made. A library to manage the database, is used for easy access to the database, and have database independence, also will be shown. Prerequites: Python 3.4, sha256, threading, queue, mysql.connector, relational database.

Patrick Mühlbauer - Split Up! Fighting the Monolith [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/split-up-fighting-the-monolith) Having to deal with a monolith, an application which became far to big over the time, can be quite bothersome. On the other hand if you split it up and have to deal with lots of smaller components, you might end up in dependency hell. But not only the splitting of the monolith and the management of the dependencies afterwards can be a problem, but also the packaging of you python components itself. ----- Do you know this situation, where you and your team are facing this big monolith? An application which has grown far too big over the years. Every time when you make a change, you have to fear the code might break at a totally different place, because lots of things are closely intertwined. But what to do if you are at such a point? Maybe you start thinking about microservices but then questions like "Are they really the right thing for us?" and "How do we get there?" arise. In my talk I will show you how we are dealing with our monolith. A collection of multiple python packages without clear boundaries, forming the actual application - all living in a single monorepo. I will talk about how we split up the whole thing, making it more flexible for us and also easier to use individual components by other teams. All this, of course, comes with a price: You have to think more about the dependencies between you components. You have to think about how you can efficiently test everything, making sure your final application is still working correctly. Don't loosing yourself in dependency hell and packaging all components correctly becomes quite a challenge. This talk will: - show you bad patterns to avoid, so that you don't end up in the above situation in the first place - give you ideas what to consider when tackling your monolith - explain how to package your python components and how to mange your dependencies

Takuro Wada - 3D Modeling and Printing by Python [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/3d-modeling-and-printing-by-python) Creating 3D model for 3D printing is pretty hard for non 3D CG designer or non 3D CAD engineer. But recently, so many 3D software (like Maya, Blender, Fusion360 and so on) provides Python API to manipulate 3D data in those software. So in this session, I will introduce Python API of Blender and Autodesk Fusion 360 and share some basic knowledge and tips when you use these API. I will also introduce my past projects with those APIs. ----- ### Abstract - Creating 3D model for 3D printing is pretty hard for **non 3D CG designer or non 3D CAD engineer**. - Recently, so many 3D software (like Maya, Blender, Fusion360 and so on) provides Python API to manipulate 3D data in those software. Once you learn these Python API, you can generate 3D model by Python and 3D print those generated model. - In this session, I will introduce Python API of some softwares and share some basic knowledges and tips when you use these API. I will also introduce my past projects with those APIs and my products. ![][1] ### Goal - Introduce 3D model generation and 3D printing with Python to audience ### After this session, you will - Acquire the basic knowledge of 3D data structure - Understand basic concepts of Python API provided by 3D softwares - Acquire knowledge to start your 3D model generation project by Python - Know past 3D model generation projects by Python ### Prerequisite - Basic knowledge of Python - Interests for 3D modeling and 3D printing by Python [1]: http://takuro.ws/img/euro_python.jpg

Sophia Davis - Peeking into Python’s C API [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/peeking-into-pythons-c-api) Ever wondered how Python works under the hood? One way to learn about Python-the-C-program is by exploring the C API for writing Python bindings to native C libraries. In this talk, we will walk through a simple example of making a C library callable from Python code and vice versa. Along the way, we will encounter some essential features of Python: reference counting, memory management, and the inner- workings of objects and modules. ----- We all love Python. It’s so elegant and easy to use as a programming language that we forget about the giant, complicated C program executing our strings of white-space sensitive code. For many Python programmers, this side of Python is just a big black box. It works well, so thankfully we don’t *need* to go messing around inside... but what if you *want* to look into the inner workings of this powerful tool? One way to dive into the C-program-side of Python is by exploring the C API for writing Python bindings to native C libraries. In this talk I will explore the basics of this API as I recount my journey to make a simple C library callable from Python code, and allow C code to invoke objects defined in pure Python. Along the way, we will encounter some essential features of Python: reference counting, memory management, and the inner-workings of objects and modules.

Ryan Lahfa - Free your papers, researchers! [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/free-your-papers-researchers) Research is financed from public money and researchers publish papers. But, papers are often unavailable to everyone except if you pay money for it, which seems wrong! What can we do as developers? Well, we can help researchers to open their papers! ----- And of course, how do we do it? Python, of course! Dissemin is a website using the Django framework which aims to promote a global Open Access policy, it offers to researchers a way to deposit legally their papers inside of a repository (Zenodo for example). We will see how the researcher world works quickly, and what are the challenges of assisting researcher to make papers available to everyone!

Björn Meier - NetworkX Visualization Powered by Bokeh [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/networkx-visualization-powered-by-bokeh) Visual data exploration, e.g. of social networks, can be ugly manual work. The talk will be an introduction for the combined usage of NetworkX and Bokeh in a Jupyter Notebook to show how easy interactive network visualization can be. ----- During some work with social network analysis my favoured tool to study the networks was NetworkX. It provides a wide set of features and algorithms for network analysis, all in Python. But the functionality to visualize networks is not very strong and not to mention the missing interactive manipulation. However during the exploration of data: exporting, feeding an extra tool for visualization and then manipulating data manually was a tedious workflow. As I also had the optional target of presenting networks in a browser, I improved this workflow by creating a Flask web application providing interfaces to my networks. On the browser side I created a javascript client based on D3.js. In retrospective the required programming effort in Python and also in Javascript was too much for such a task. And exactly this target, interactive visualization in a browser (and as bonus in a Jupyter Notebook), can be achieved quiet easy now with Bokeh. The talk will be a step by step introduction, starting with the basic visualization of a network using Bokeh, NetworkX and a Jupyter Notebook. Next, how to create interactions with your network which will be used to change a network structure, e.g. a leaving person. As we want to see directly the impact of these changes in a network I will finally show how to update networks and visualize directly how the importance of the remaining people changes. And all this can be achieved with Python and maybe a bit of Javascript. (There was no video for the first few minutes of this talk).

Alexandre Savio - Nipy on functional brain MRI [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/nipy-on-functional-brain-mri) This is an introductory talk to modern brain image analysis tools. I will show how to use nipy tools to process one resting-state fMRI subject, perform intra-subject registration, ICA analysis to extract and visualize resting-state networks. If the time allows me I will introduce an anatomical brain atlas and how to perform non-linear registration to do atlas-based segmentation. ----- This is an introductory talk to modern brain image analysis tools. I will show how to use nipy tools to process one resting-state fMRI subject, perform intra-subject registration, ICA analysis to extract and visualize resting-state networks. If the time allows me I will introduce how to perform non-linear registration to to atlas-based segmentation. The outline of the talk: 1. Present the COBRE dataset and show its characteristics. 2. Use nibabel to open a NifTI file and see the matrix/volume parameters. 3. Use nilearn.plotting to show the anatomical image. 4. Use nipy to co-register the anatomical image to the fMRI image. 5. Use nilearn to perform CanICA and plot ICA spatial segmentations. If time allows: 7. Present a brain anatomical atlas and its template. 8. Present the tools needed for non-linear registration. 9. Show the result of an atlas-based segmentation result. 10. Use nilearn to calculate the resting-state functional connectivity matrix of the subject. 11. Plot it with Bokeh.

Michele Simionato - How to migrate from PostgreSQL to HDF5 and live happily ever after [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/how-to-migrate-from-postgresql-to-hdf5-and-live-happily-ever-after) This talk is for people who have a lot of floating numbers inside PostgreSQL tables. I will bring as an example my personal experience with a scientific project that used PostgreSQL as storage for a rather complex set of composite multidimensional arrays and ran into all sorts of performances issues, both in reading and writing the data. I will explain how I solved all that by dropping the database in favor of an HDF5 file, while keeping the application running and the users happy. ----- This talk is for people who have a lot of floating numbers inside PostgreSQL tables and have problems with that. I will narrate my experience with a scientific project that used PostgreSQL as storage for a rather complex set of composite multidimensional arrays and ran into all sorts of performances issues, both in reading and writing the data. I will discuss the issues and the approach that was taken first to mitigate them (unsuccessfully) and then to remove them (successfully) by a complete rethinking of the underlying architecture and eventually the removal of the database. I will talk about the migration strategies that were employed in the transition period and how to live with a mixed environment of metadata in PostgreSQL and data in an HDF5 file. I will also talk about concurrency, since the underlying application is distributed and massively parallel, and still it uses the purely sequential version of HDF5. Questions from the audience are expected and welcome. The talk is of interest to a large public, since it is mostly about measuring things, monitoring and testing a legacy system, making sure that the changes do not break the previous behavior and keeping the users happy, while internally rewriting all of the original code. And doing that in a small enough number of years!

Olga Lyashevska - How can machine learning help to predict changes in size of Atlantic herring ? [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/how-can-machine-learning-help-to-predict-changes-in-size-of-atlantic-herring) This talk is a case-study of how Python (Pandas, NumPy, SciKit-learn) can be implemented to identify the influence of the potential drivers of a decline in size of Atlantic herring populations using Gradient Boosting Regression Trees. ----- A decline in size and weight of Atlantic herring in the Celtic Sea has been observed since the mid-1980’s. The cause of the decline remains largely unexplained but is likely to be driven by the interactive effect of various endogenous and exogenous factors. The goal of this study is to interrogate a long time-series of biological data obtained from commercial fisheries from 1959 to 2012. We use gradient boosting regression trees to identify important variables underlying changes in growth from various potential drivers, such as: - Atlantic multidecadal oscillation; - sea surface temperature; - salinity; - wind; - zooplankton abundance; - fishing pressure. This learning algorithm allows to quantify the influence of the potential drivers of change with the test error lower when compared to other supervised learning techniques. The predictor variables importance spectrum (feature importance) helps to identify the underlying patterns and potential tipping points while resolving the external mechanisms underlying observed changes in size and weight of herring. This analysis is a useful case-study of how Python can be implemented in academia. The outputs of the analysis are of relevance to conservation efforts and sustainable fisheries management which promotes species resistance and resilience.

Ralph Heinkel - The value of mindfulness and how it has arrived at Google [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/the-value-of-mindfulness-and-how-it-has-arrived-at-google) Mindfulness has proven to be a foundational skill that started as a pure buddhist practice. Nowadays mindfulness serves as the core technique of several western programs ranging from curing stress- induced medical problems to curricula for teaching successful business leadership, such as the Search Inside Yourself program developed at Google. The aim of this seminar is to provide a practical experience of mindfulness with a short introduction to how it can be applied by digital workers. ----- Mindfulness has proven to be a foundational skill that started as a pure buddhist practice. Nowadays mindfulness serves as the core technique of several western programs ranging from curing stress- induced medical problems to curricula for teaching successful business leadership, such as the Search Inside Yourself (SIY) program developed at Google in 2002. Mind is the root of all things. Neuroscience shows that attention is a fundamental function of the mind. Being able to direct attention to the present moment - and keep it there while performing daily tasks - is a great tool to navigate through life and its challenges with more engagement, more happiness, and more resilience. Focusing attention in a relaxed way enables us to disconnect from the overall noise found in a high-speed environment and get things done without feeling too overwhelmed by them. But being effective is not only about checking off more tasks - it is about how we are in resonance with our environment, how we interact with others, and how we face the increasing complexity in our professional life. The aim of this seminar is to provide a practical experience of mindfulness with a short introduction to how it can be applied in a technology driven world as experience by digital workers.

Honza Král - Log all the things! [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/log-all-the-things) Many times these logs are thrown away or just sit uselessly somewhere on disk. I would like to show you how you can make sense of all that data, how to collect and clean them, store them in a scalable fashion and, finally, explore and search across various systems. ----- Centralized logging (and the ELK stack) is proving itself to be a very useful tool in managing a production infrastructure. When combined with other data sources (application logging, business data, ...) it can provide even more insight. This talk is an introduction into the area with some overview of the motivation, tools and techniques that can prove useful. We will show how the open source ELK (Elasticsearch Logstash and Kibana) stack can be used to implement this. It is geared towards people familiar with the DevOps concept that are looking to improve their lives by introducing smarter tools.

Alessandro Amici - Test-driven code search and reuse coming to Python with pytest-nodev [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/test-driven-source-code-search-for-python-with-pytest-nodev) We will present the test-driven reuse (TDR) development strategy, a natural extension of test-driven development (TDD), and how to execute it with [pytest-nodev][1] a test-driven search engine for Python code. [1]: http://pytest-nodev.readthedocs.io/en/stable/quickstart.html Pytest-nodev and the other nodev tools that helps implement TDR for Python are rather new, in spite of that we will present several successful applications of the technique to more and more complex examples. ----- We will present the test-driven reuse (TDR) development strategy, a natural extension of test-driven development (TDD), and how to execute it with [pytest-nodev](http://pytest- nodev.readthedocs.io/en/stable/quickstart.html) an Open Source test- driven search engine for Python code. When developing new functionalities developers spend significant efforts searching for code to reuse, mainly via keyword-based searches, e.g. on StackOverflow and Google. Keyword-based search is effective in finding code that is explicitly designed and documented to be reused, e.g. libraries and frameworks, but typically fails to identify reusable functions and classes in the large corpus of auxiliary code of software projects. TDR aims to address the limits of keyword-based search with test- driven code search that focuses instead on code behaviour and semantics. Developing a new feature in TDR starts with the developer writing the tests that will validate candidate implementations of the desired functionality. Before writing any functional code the tests are run against all functions and classes of available projects. Any code passing the tests is presented to the developer as a candidate implementation for the target feature. [Pytest-nodev](https://github.com/nodev-io/pytest-nodev) and other nodev tools that help implement TDR for Python are newer than the JAVA counterparts, in spite of that we will present several applications of the technique to more and more complex examples.

Tariq Rashid - A Gentle Introduction to Neural Networks (with Python) [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/a-gentle-introduction-to-neural-networks-with-python) A gentle introduction to neural networks, and making your own with Python. This session is deliberately designed to be accessible to everyone, including anyone with no expertise in mathematics, computer science or Python. From this session you will have an intuitive understanding of what neural networks are and how they work. If you are more technically capable, you will see how you could make your own with Python and numpy. ----- Part 1 - Ideas: - the search for AI, hard problems for computers easy fro humans - learning from examples (simple classifier) - biologically inspired neurons and networks - training a neural network - the back propagation breakthrough - matrix ways of working (good for computers) Part 2 - Python: - Python is easy, and everywhere - Python notebooks - the MNIST data set - a very simple neural network class - focus on concise and efficient matrix calculations with bumpy - 97.5% accuracy recognising handwritten numbers - with just a few lines of code! Part 3 - Q&A

Geoff French - An Introduction to Deep Learning [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/an-introduction-to-deep-learning) Deep learning: how it works, how to train a deep neural network, the theory behind deep learning, recent developments and applications. (length: 60 mins) ----- (length: 60 mins) In the last few years, deep neural networks have been used to generate state of the art results in image classification, segmentation and object detection. They have also successfully been used for speech recognition and textual analysis. In this talk, I will give an introduction to deep neural networks. I will cover how they work, how they are trained, and a little bit on how to get going. I will briefly discuss some of the recent exciting and amusing applications of deep learning. The talk will primarily focus on image processing. If you completely new to deep learning, please attend T. Rashid's talk 'A Gentle Introduction to Neural Networks (with Python)'. His talk is in the same room immediately before mine and his material is really good and will give you a good grounding in what I will present to you. :) You may also want to attend I' Lewis' talk 'Deep Learning with Python & TensorFlow' after Lunch in the PyCharm room to round it all off! :)

Bargava Subramanian - Machine Learning: Power of Ensembles [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/machine-learning-power-of-ensembles) In Machine Learning, the power of combining many models have proven to successfully provide better results than single models. The primary goal of the talk is to answer the following questions: 1) Why and How ensembles produce better output? 2) When data scales, what's the impact? What are the trade-offs to consider? 3) Can ensemble models eliminate expert domain knowledge? ----- It is relatively easy to build a first-cut machine learning model. But what does it take to build a reasonably good model, or even a state- of-art model ? Ensemble models. They are our best friends. They help us exploit the power of computing. Ensemble methods aren't new. They form the basis for some extremely powerful machine learning algorithms like random forests and gradient boosting machines. The key point about ensemble is that consensus from diverse models are more reliable than a single source. This talk will cover how we can combine model outputs from various base models(logistic regression, support vector machines, decision trees, neural networks, etc) to create a stronger/better model output. This talk will cover various strategies to create ensemble models. Using third-party Python libraries along with scikit-learn, this talk will demonstrate the following ensemble methodologies: 1) Bagging 2) Boosting 3) Stacking Real-life examples from the enterprise world will be show-cased where ensemble models produced better results consistently when compared against single best-performing models. There will also be emphasis on the following: Feature engineering, model selection, importance of bias-variance and generalization. Creating better models is the critical component of building a good data science product. A preliminary version of the slides is available [here](https://speakerdeck.com/bargava/power-of-ensembles)

Gaël Varoquaux - Scientist meets web dev: how Python became the language of data [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/keynote-science-web-dev) Data science is a hot topic and Python has emerged as an ideal language for it. Its strength for data analysis come from the cultural mix between the scientific Python community, and more conventional software usage, such as web development or system administration. I'll show how and why Python is a easy and powerful tool for data science. ----- Python started as a scripting language, but now it is the new trend everywhere and in particular for data science, the latest rage of computing. It didn't get there by chance: tools and concepts built by nerdy scientists and geek sysadmins provide foundations for what is said to be the sexiest job: data scientist. In my talk I'll give a personal perspective, historical and technical, on the progress of the scientific Python ecosystem, from numerical physics to data mining. What made Python suitable for science; How could scipy grow to challenge commercial giants such as Matlab; Why the cultural gap between scientific Python and the broader Python community turned out to be a gold mine; How scikit-learn was born, what technical decisions enabled it to grow; And last but not least, how we are addressing a wider and wider public, lowering the bar and empowering people. The talk will discuss low-level technical aspects, such as how the Python world makes it easy to move large chunks of number across code. It will touch upon current exciting developments in scikit-learn and joblib. But it will also talk about softer topics, such as project dynamics or documentation, as software's success is determined by people.

Armin Rigo - CFFI: calling C from Python [EuroPython 2016] [20 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/cffi-calling-c-from-python) In this talk, we will see an intro to CFFI, an alternative to using the standard C API to extend Python. CFFI works on CPython and on PyPy. It is a possible solution to a problem that hits notably PyPy --- the CPython C API. The CPython C API was great and contributed to the present-day success of Python, together with tools built on top of it like Cython and SWIG. I will argue that it may be time to look beyond it, and present CFFI as such an example. ----- I will introduce CFFI, a way to call C libraries from Python. http://cffi.readthedocs.org/ CFFI was designed in 2012 to get away from Python's C extension modules, which require hand-written CPython-specific C code. CFFI is arguably simpler to use: you call C from Python directly, instead of going through an intermediate layer. It is not tied to CPython's internals, and works natively on two different Python implementations: CPython and PyPy. It could be ported to more implementations. It is also a big success, according to the download statistics. Some high-visibility projects like Cryptography have switched to it. Part of the motivation for developing CFFI is that it is a minimal layer that allows direct access to C from Python, with no fixed intermediate C API. It shares ideas from Cython, ctypes, and LuaJIT's ffi, but the non-dependence on any fixed C API is a central point. It is a possible solution to a problem that hits notably PyPy --- the CPython C API. The CPython C API was great and, we can argue, it contributed a lot to the present-day success of Python, together with tools built on top of it like Cython and SWIG. However, it may be time to look beyond it. This talk will thus present CFFI as such an example. This independence is what lets CFFI work equally well on CPython and on PyPy (and be very fast on the latter thanks to the JIT compiler).

Fabio Pliger/Marc-André Lemburg - Closing Session [EuroPython 2016] [22 July 2016] [Bilbao, Euskadi, Spain] (https://ep2016.europython.eu//conference/talks/closing-session) Closing Session