Show filters Hide filters

Refine your search

Publication Year
1-12 out of 120 results
Change view
  • Sort by:
49:44 EuroPython English 2014

Python's Role in Big Data Analytics: Past, Present, and Future

Travis Oliphant - Python's Role in Big Data Analytics: Past, Present, and Future Python has had a long history in Scientific Computing which means it has had the fundamental building blocks necessary for doing Data Analysis for many years. As a result, Python has long played a role in scientific problems with the largest data sets. Lately, it has also grown in traction as a tool for doing rapid Data Analysis. As a result, Python is the center of an emerging trend that is unifying traditional High Performance Computing with "Big Data" applications. In this talk I will discuss the features of Python and its popular libraries that have promoted its use in data analytics. I will also discuss the features that are still missing to enable Python to remain competitive and useful for data scientists and other domain experts. Finally, will describe open source projects that are currently occupying my attention which can assist in keeping Python relevant and even essential in Data Analytics for many years to come.
  • Published: 2014
  • Publisher: EuroPython
  • Language: English
1:22:46 EuroPython English 2014

EuroPython 2014: July 22, 2014 - Lightning Talks

Lightning Talks: Elliptics: Anton Tyurin, On Being Super: Austin Bingham, PYCON Finland: Mikko Ohtamaa, Regularities in language: Dmitrijs Milajevs, pip install pyladies: Lynn Root, Iktomi Forms: Harut Dagesyan, Killer Robots: Radomir Dopieralski, ZeroVM: Lars Butler, Zombies and Application Runtimes: Dmitry Jemerov, FritzConnection - Communicate with the AVM Fritz Box: Klaus Bremer, Argment Clinic: Larry Hastings, PEP 473: Adding structured data to builtin exceptions: Sebastian Kreft, Supporting Python 2 and Python 3 witth the same source code: Stefan Schwarzer, Birthday: Mark Shannon, nsupdate.info bepasty: Thomas Waldmann, Python Core Security: Christian Heimes, Hands On Unix: Rok Garbas, Deproulette: Joar Wandborg
  • Published: 2014
  • Publisher: EuroPython
  • Language: English
1:16:08 EuroPython English 2014

EuroPython 2014: July 25, 2014 - Lightning Talks

Lightning Talks: Sparts - Quick service Prototyping: Manu, Blinky's Async Adventure: Petr Viktorin, Tryton Unconference Leipzig 2014: Udono, Yet another conference announcement: Baptiste Mispelon, Configurable omnipotent custom applications integrated network engine: Anton Tyurin, What we did at #ep14: "vtemian" Vlad Temian, Foreman client: Lukas Bednar, HSTS: Abraham Martin, PyAr Pablo G. Celayes, Celia Cintas, Python Quantum Platform: Yves J. Hilpisch, CodeWeek.eu: Erika Pogorelc, Our beautiful minds: Remco Wendt, Stackless - Best Ever: Christian Tismer, Stella: Compiling a small subset of Python: David Mohr, Plone Mosiac Sprint Barcelona: Philip Bauer
  • Published: 2014
  • Publisher: EuroPython
  • Language: English
48:00 EuroPython English 2014

The Cython Compiler for Python

Stefan Behnel - The Cython Compiler for Python The Cython compiler is the most widely used static compiler for Python. It is used to speed up Python code and to extend CPython with fast native extension modules that process huge amounts of data all around the world. This talk by one of the core developers gives an intro to using the compiler and an overview of its major features. ----- The Cython compiler is the most widely used static compiler for Python. The code it generates is used in countless critical applications that process huge amounts of data world wide. Cython has two major use cases: to compile Python code into fast native extension modules, and to connect native code to the CPython runtime. The main goal of the Cython project is to make it easy for users to manually optimise their Python code to make it run at C speed. This talk by one of the core developers will give an intro to using the compiler and an overview of its major features. Outline will be more or less as follows: * Cython: intro to the project and the compiler (4 min.) * compiling Python code - how to do it and what you get (3 min.) - a tiny bit of distutils (2 min.) * static typing and Cython extensions to the Python language - static typing in Cython language syntax (3 min.) - static typing in pure Python syntax (2 min.) - why Cython's type system is cool and what users need to know about it (8 min.) - Cython for optimising Python code (5 min.) * quick intro: talking to native C/C++ code in Cython - using external C APIs (4 min.) - using external C++ APIs (3 min.) - how to build and link in distutils (2 min.) - notes on ways to wrap large C-APIs (1 min.) * quick overview: special features for high-performance code - NumPy integration and memory views, fused types, parallel loops in all brevity (3 min.)
  • Published: 2014
  • Publisher: EuroPython
  • Language: English
48:27 EuroPython English 2014

Performance Python for Numerical Algorithms

Yves - Performance Python for Numerical Algorithms This talk is about several approaches to implement high performing numerical algorithms and applications in Python. It introduces into approaches like vectorization, multi-threading, parallelization (CPU/GPU), dynamic compiling, high throughput IO operations. The approach is a practical one in that every approach is illustrated by specific Python examples. The talk uses, among others, the following libraries: * NumPy * numexpr * IPython.Parallel * Numba * NumbaPro * PyTables
  • Published: 2014
  • Publisher: EuroPython
  • Language: English
27:50 EuroPython English 2014

Twisted Names

Richard Wall - Twisted Names: DNS Building Blocks for Python Programmers In this talk I will report on my efforts to update the DNS components of Twisted and discuss some of the things I've learned along the way. I'll demonstrate the EDNS0, DNSSEC and DANE client support which I have been working on and show how these new Twisted Names components can be glued together to build novel DNS servers and clients. Twisted is an event-driven networking engine written in Python and licensed under the open source MIT license. It is a platform for developing internet applications.
  • Published: 2014
  • Publisher: EuroPython
  • Language: English
23:34 EuroPython English 2014

Jigna: a seamless Python-JS bridge to create rich HTML UIs for Python apps

Prashant Agrawal - Jigna: a seamless Python-JS bridge to create rich HTML UIs for Python apps Jigna aims to provide an easy way to create rich user interfaces for Python applications using web technologies like HTML, CSS and Javascript, as opposed to widget based toolkits like Qt/wx or native toolkits. It provides a seamless two-way data binding between the Python model and the HTML view by creating a Python-JS communication bridge. This ensures that the view is always live as it can automatically update itself when the model changes, and update the model when user actions take place on the UI. The Jigna view can be rendered in an in-process Qt widget or over the web in a browser.
  • Published: 2014
  • Publisher: EuroPython
  • Language: English
39:57 EuroPython English 2014

Support Python 2 and 3 with the same code

Stefan Schwarzer - Support Python 2 and 3 with the same code Your library supports only Python 2, - but your users keep nagging you about Python 3 support? As Python 3 gets adopted more and more, users ask for Python 3 support in existing libraries for Python 2. This talk mentions some approaches for giving users a Python 3 version, but will quickly focus on using the very same code for a Python 2 and a Python 3 version. This is much easier if you require Python 2.6 and up, and yet a bit easier if you require Python 3.3 as the minimum Python 3 version. The talk discusses main problems when supporting Python 3 (some are easily solved): * `print` is a function. * More Python APIs return iterators that used to return lists. * There's now a clear distinction between bytes and unicode (text) strings. * Files are opened as text by default, requiring an encoding to apply on reading and writing. The talk also explains some best practices: * Start with a good automatic test coverage. * Deal with many automatic conversions with a one-time 2to3 run. * Think about how your library should handle bytes and unicode strings. (Rule of thumb: Decode bytes as early as possible; encode unicode text as late as possible.) * Should you break compatibility with your existing Python 2 API? (Yes, if there's no other way to design a sane API for Python 2 and 3. If you do it, raise the first part of the version number.) * Try to keep code that's different for Python 2 and 3 minimal. Put code that needs to be different for Python 2 and 3 into a `compat` module. Or use third-party libraries like `six` or `future`. Finally, the talk will mention some helpful resources on the web.
  • Published: 2014
  • Publisher: EuroPython
  • Language: English
40:38 EuroPython English 2014

Design considerations while Evaluating, Developing, Deploying a distributed task processing system

konarkmodi - Design considerations while Evaluating, Developing, Deploying a distributed task processing system With the growing world of web, there are numerous use-cases which require tasks to be executed in an asynchronous manner and in a distributed fashion. Celery is one of the most robust, scalable, extendable and easy-to-implement frameworks available for distributed task processing. While developing applications using Celery, I have had considerable experience in terms of what design choices one should be aware of while evaluating an existing system or developing one's own system from scratch.
  • Published: 2014
  • Publisher: EuroPython
  • Language: English
22:39 EuroPython English 2014

3D sensors and Python: A space odyssey

Celia - 3D sensors and Python: A space odyssey This talk will show how to build a simple open source based NUI (Natural User Interface) game with 3D Sensors, incorporating PyOpenNI with PyGame and WebGL. OpenNI allows you operate several 3D sensors, enabling hardware independent game development (supported 3D sensors are Microsoft Kinect, PrimeSense Carmine or Asus XTion). It also runs on Linux, Mac OS X and Windows. ----- This talk will start with a brief introduction to 3D Sensors and OpenNI. Then we’ll surf into PyOpenNI, features such as the skeleton, hand and gesture tracking, RGB and depth video. Every topic will be presented with practical demos. The talk will end with a demo integrating WebGL (THREE.JS), 3D sensors, Flask and ZMQ to produce a simple fully open source based NUI game. Attendees will not only learn about game related technologies but also about innovative ways of doing domotics, cinema & art, Interactive visualization, scientific research, educations, etc. 3D Sensors will be available for testing during the event - you can get yours for about 80 to 140 Euros (depending on the brand). Slides and demo code will be available at Github. Talk structure: * Introduction: hardware and OpenNI goodies and a tale of PCL (5’) * Hands On PyOpenNI * Normal and Depth camera - basics concepts and small demo (5’) * Skeleton - basics concepts and small demo. (5’) * Hand & gesture - basics concepts and small demo. (5’) * Final Demo * What we’re going to use? Flask, ZMQ, THREE.JS, PyOpenNI. (6’) * Q&A. (4’)
  • Published: 2014
  • Publisher: EuroPython
  • Language: English
39:59 EuroPython English 2014

Systems Integration: The OpenStack success story

Flavio Percoco - Systems Integration: The OpenStack success story OpenStack is a huge, open-source cloud provider. One of the main tenets of OpenStack is the (Shared Nothing Architecture) to which all modules stick very closely. In order to do that, services within OpenStack have adopted different strategies to integrate themselves and share data without sacrificing performance nor moving away from SNA. This strategies are not applicable just to OpenStack but to any distributed system. Sharing data, regardless what that data is, is a must-have requirement of any successful cloud service. This talk will present some of the existing integration strategies that are applicable to cloud infrastructures and enterprise services. The talk will be based on the strategies that have helped OpenStack to be successful and most importantly, scalable. Details ====== Along the lines of what I've described in the abstract, the presentation will walk the audience through the state of the art of existing system integration solutions, the ones that have been adopted by OpenStack and the benefits of those solutions. At the end of the talk, a set of solutions under development, ideas and improvements to the existing ones will be presented. The presentation is oriented to distributed services, fault-tolerance and replica determinism. It's based on a software completely written in python and running successfully on several production environments. The presentation will be split in 3 main topics: Distributed System integration ----------------------------------- * What's it ? * Why is it essential for cloud infrastructures? * Existing methods and strategies OpenStack success story ---------------------------- * Which methods did OpenStack adopt? * How / Why do they work? * What else could be done? Coming Next --------------- * Some issues of existing solutions * What are we doing to improve that? * Other solutions coming up
  • Published: 2014
  • Publisher: EuroPython
  • Language: English
40:20 EuroPython English 2014

Rethinking packaging, development and deployment

Domen Kožar - Rethinking packaging, development and deployment In Python, we're trying to solve packaging problems in our own domain, but maybe someone else already solved most our problems. In the talk I'll show how I develop and deploy Python projects that can be easily mixed with non-Python dependencies. "Nix" will be demonstrated to replace technologies in our stack: pip, virtualenv, buildout, ansible, jenkins. ----- Python is often mixed with other languages in development stack, nowadays it's hard to escape any JavaScript dependencies. If you add some C dependencies such as GStreamer to the stack, packaging becomes a burden. While tweaking our packaging infrastructure will make things better, it's hard to fix fundamental problem of packaging with current ad-hoc solutions in Python domain. Using Nix for about a year gave me an insight that solving packaging problem at operating system level (bottom-up) is a better approach. For example, wouldn't it be cool to have "virtualenv" implemented inside your package manager, so you could isolate also non-Python dependencies and not just Python packages for your project and not worry if system was updated? We'll also show what benefits do we get by using the same tool for development and deployment and how little we have to do to deploy our application.
  • Published: 2014
  • Publisher: EuroPython
  • Language: English
out of 10 pages
Loading...
Feedback
AV-Portal 3.6.0 (ecdfbe1492e563fa2305056b6ba267cdae273179)

Timings

 1040 ms - page object
   76 ms - search
   10 ms - highlighting
    2 ms - highlighting/20043
    1 ms - highlighting/20054
    1 ms - highlighting/20051
    0 ms - highlighting/20033
    1 ms - highlighting/20050
    1 ms - highlighting/20024
    0 ms - highlighting/20020
    1 ms - highlighting/20034
    1 ms - highlighting/19961
    1 ms - highlighting/19952
    0 ms - highlighting/19971
    1 ms - highlighting/19964