The OpenStack Community has grown by leaps and bounds. On January 2011 there were 71 thousand lines of code and 61 developers. Today there are 821 active developers, 896 thousand lines of code and over 2 thousand commits per month! According to Ohloh, 'this is one of the largest open-source teams in the world, and is in the top 2% of all project teams on Ohloh.'

Keeping development running at this scale quickly becomes challenging, especially while trying to keep development as accessible possible. In this talk we'll cover how OpenStack's code review process has evolved to work at scale and how you can get involved.

Infographics or data visualisations tend to be the output of journalistic or scientific research. You may be wowed by their aesthetics or insightfulness, but that is usually the end of the story. However, if you turn the process on its end and treat visualisations as an input rather than as an output, you might see things from an entirely different perspective. In this talk, I will talk about the journey I took while exploring this possibility, sharing some tips to make your data visualisation more engaging and perhaps even convincing you to give the d3 JavaScript library a try.

Most Ruby implementations are written in languages like C, or target existing VMs like the JVM. Topaz is a Ruby interpreter written in RPython, using the same framework that powers PyPy. This talk explores how this process works, what the code looks like, and what the benefits are. It will also include a report of the current status of Topaz.

Software complexity is ever-increasing. Over the years, we've built abstractions on abstractions on abstractions. The result of all that building is that most software developers spend the vast majority of their time working near the top of the stack, and that fewer and fewer of us know much about what happens underneath.

The many different types of connected devices are increasing dramatically. We already have a large amount of duplicate code between client applications (both native and web), and the increasing number of devices is only making this worse. Also, cheap low-end devices are gaining greater market shares, and users expect a good experience when using our software on them.

To solve the problem of code duplication on the clients, we need to pull as much of it as we can back from the clients to the server. A good way to achieve this is to build a Hypermedia API and to use HTML as the media type for the API. A nice side-effect of this is that we can show the received HTML directly to the user, which will be good enough for a majority of client applications.

The problem of low-profile devices is best solved by using Adaptive Web Design, which will allowing developers to provide the best experience that the device is capable of delivering. Finally, combining HTML Hypermedia APIs and Adaptive Web Design will allow a single endpoint for our web and our API.

There are a few aspects of IPython's relationship with languages other than Python, and I would be happy to discuss any or all of them as appropriate, given time / interest of the audience:

• Language magics for running one cell in another language (%%R, %%Julia, etc.)
• Non-Python kernels (IPython is really a REPL message protocol now, so any language can implement a kernel - node, ruby, and Julia all have demo implementations)
• The IPython Notebook itself as a multi-language environment:
  • Python for kernel-side code
  • Markdown for rich text
  • LaTeX for math
  • Javascript for dynamic / interactive output

After working as a community manager for over 5 years I missed 'making stuff' and I started learning Rails and Ruby in August last year. Now that I'm confident with CSS, Less and Rails, I want to share my learnings when it comes to learning and teaching programming. As a newbie to programming I'm spending my weekends learning about technologies like CoffeeScript or Python, or about version control, libraries, gems and generally useful resources out there. I genuinely believe that teaching skyrockets one's own learning curve and I would encourage everyone to start coaching beginners to programming, even if you consider yourself to be a beginner still.

Javascript development has come a long way in the last ten years. Aside from its meteoric rise in terms of popularity and discovered functionality, web apps using Javascript have seen a rise in complexity when it comes to packaging and delivery of application code. Long gone are the days of sending individual, unminified files to the browser, replaced now with the combine-and-minify approach, but as client applications get fatter, the days are numbered for this method too.

The good news here is that Javascript development and tooling has been moving in a direction that puts us in a great position to level up the way that code is delivered, and of course, when it comes to modifying Javascript, what better language is there to use than Javascript itself?

In this talk, I'll be discussing the options for managing your build process, looking at third party systems, but more importantly, how you can put your own together for the ultimate custom build.

I'm teaching a week-long intro to programming class for high school students at a non-profit summer school program in July. I'll plan to talk about the browser-based open source tools that I've built to facilitate the course as well as my first experience teaching it: what worked, and what I need to do differently next time.

While Java and C# use static type declarations to eliminate ambiguity, the dynamic-language programmer must survive through sheer clarity and consistency in naming variables. We will explore the deep unspoken conventions that the Python community has developed and honed over two decades to make Python code readable and meaningful within the freedom that a dynamically-typed language grants us.

I'd like to show how, using elasticsearch, you can make sense of your data, discover and explore interesting trends in our users' behavior, create custom dashboards for your users as well as for yourself.

Substance D is a new Python web application server that can be used to build content management systems, intranets, and bespoke applications. It features a management UI, undo, and other useful doodads.

How to make your work scale better. Not just handle more transactions but scale better in time as your infrastructure expand, your employee numbers go up (but some leave), new employees come in with new tools and expertise. What kind of hardware and software philosophy have helped top performing organization maintain speed as the complexity grows.

Latest NSA and PRISM news show how valuable a pure European infrastructure can be. It stands for independence and freedom of information. This is also applicable for hosting because a hosting provider has ultimate access to incoming and outgoing data.

In this talk you will learn how to bootstrap a European NSA- and PRISM-free PaaS with Open source Cloud Foundry using the example of anynines.

Get insights about the building blocks of such a Heroku like infrastructure, how apps are distributed, how services are provisioned and learn more about how Heroku buildpacks can be used to run apps of any language and framework.

Bosh helps you to discover how a PaaS can remain independent of IaaS layers and easily run on VMWare or OpenStack.

Explore how a PaaS is managed, scaled and upgraded.

Furthermore see how easy it is to add new services to a Cloud Foundry PaaS.

At the end of this talk you will know how to build your own PaaS.

Gone are the days of the solitary astronomer up late in a cold dome, staring through the eyepiece of a telescope. Modern astronomy research is characterized by automated digital surveys which create floods of imagery and other data, too voluminous for even large teams of Astronomers to analyze by-eye. Starting in the second half of this decade, the Large Synoptic Survey Telescope (LSST) will push the boundary even further by repeatedly image the entire southern sky over the course of ten years. The resulting data stream will effectively be a ten-year movie of the night sky, comprising hundreds of petabytes of raw data in the end, and will lead to an unprecedented ability to understand the physics of the universe, from gigantic nuclear explosions at the centers of galaxies, to orbits of extrasolar planets around distant stars, to the accelerating expansion of space itself. In this talk, I’ll highlight some of the more exciting prospects for science with LSST, and highlight how Python is being utilized within astronomy to encourage open, reproducible research as we process, analyze, and share our data.

The key to understanding Clojure is ideas, not language constructs. In this talk, we will approach Clojure via 10 Big Ideas:

• edn
• Persistent Data Structures
• Atomic Success Model
• Seqs
• Protocols
• ClojureScript
• Reducers
• core.logic
• Datalog
• core.async

Each of these ideas is valuable and useful a la carte, and not necessarily only in Clojure. Taken together, they beging to fill in the picture of why Clojure is changing the way many programmers think about software development.

It is know that in the IT industry project have a high percentage of failure. But what if we could see the warning signs before it is too late?

In this presentation, Yann Larrivée will explain through story telling the 10 warning signs you should look for throughout the implementation of your project in order to prevent many sleepless nights and project failure. For each warning signs one or more solutions will be given.

The way act every day is changing the Community and the world we live. How can we, as developers or as communities, address this change?

Docker is an open-source project to easily create lightweight, portable, self-sufficient containers from any application. The same container that a developer builds and tests on a laptop can run at scale, in production, on VMs, bare metal, OpenStack clusters, public clouds and more.

This talk aims at introducing Docker to developers, how to use it efficiently and build a workflow that includes it.

When developers talk about Domain Driven Design they usually talk about Java or C# implementation and it seems that languages like Ruby or Python are not suited for these kind of architectures. During the talk I would like to show that every patterns described in the blue book can be written even in Ruby and sometimes the Ruby implementation is better than the Java one. Ruby is not a second a class language and its dynamic power could help a lot in writing complex business logic.

To provide an industry leading support experience for our users, I as the lead engineer at Prezi Support always try to find great solutions to help our agents. Recently, we created a web-based CRM system to make agents more productive. Using a client side MVC was a no-brainer (we replaced a generated admin solution). Now we can engineer high-speed, non-traditional, and easy-to-use user interfaces. We selected a framework that was best for our goals and implemented our key features with the most popular variations. I will share these implementations and introduce the strengths and weaknesses of Backbone.js, Ember.js and Angular.js. As we ended up selecting Angular.js, (it’s feature-rich, standard-friendly, easy to test and extend, as well as being popular), I will go a lot deeper into its details. It emerged as the best solution for us and maybe it’s the most future proof decision for everyone.

It's been scientifically proven that more diverse communities and workplaces create better products and the solutions to difficult problems are more complete and diverse themselves. Companies are struggling to find adequate talent. So why do we see so few women, people of color, and LGBTQ people at our events and on the about pages of our websites? Even more curiously, why do 60% of women leave the tech industry within 10 years? Why are fewer women choosing to pursue computer science and related degrees than ever before? Why have stories of active discouragement, dismissal, harassment, or worse become regular news?

In this talk we’ll examine the causes behind the lack of diversity in our communities, events, and workplaces. We’ll discuss what we can do as community members, event organizers, and co-workers to not only combat this problem, but to encourage positive change by contributing to an atmosphere of inclusivity."

REST has become the standard way of creating web APIs for a reason: it's easy to understand, doesn't need a dedicated client, and plays nicely with HTTP. But even in dynamically typed languages like Python, Ruby and JavaScript the schemaless nature of REST makes maintaining servers and clients for these APIs a nightmare. Protocol Buffers and Thrift, Google and Facebook's answers to this problem allow us to create API's that are strictly typed, backwards compatible, easy to code with and bandwidth-efficient.

At Prezi.com, we are adding thrift interfaces to our django services. I'd like to share what worked, what was difficult, and how much easier it is to consume our new internal APIs. In the process, we created libraries we hope to open source in the near future.

Prezi.com has been python-powered from the start.

That's about the only thing that has remained constant in Prezi.com's codebase as it grew. Along the way, we've had to solve all sorts of interesting problems. Partly technical, partly organization, all of them had an effect on how we create python code.

What's the best way to deploy our application? How do we organize our code? What kind of tests do we write? How should we communicate over the network? How do we give back to the community?

Our answers to all of these questions evolved with time. It's fascinating to look back and see all the different approaches we tried. Some were successful, some failed, but all of these experiments contributed to what we have today: python-powered applications serving 25+ million users' presentations.

Lot of people are trying to port the actor pattern to Python, but this pattern isn't really designed for such languages. On the contrary the Go concurrency model has some attractive points that can be easily ported to Python. This talk will describe the go concurrency model and my own experimentation actually named flower to port it in Python. In this talk you will see how I am using greenlets or generators to handle corountines and optionally use pyuv to manage a non blocking IO poll server.

Following the rise of Clojure, many of us have become aware of the idea of immutable data structures and their benefits. In Clojure, all built-in data structures are immutable, and the same also applies to everything we build out of them. This has profound effects on how programs are constructed and transforms the way we can reason about them, test them, compose them, and drop them into concurrent environments.

But what is the immutability story in Ruby, JavaScript, and Python? Is immutability just a Clojure or a functional thing, or does it apply to the type of OO programs we build with these other languages? If we do want to utilize immutable data in Ruby, JavaScript, or Python, how should we go about it? What built-in data structures can we use and what should we stay away from? What libraries are there to help us? How should we construct our programs - in the small and in the large?

This talk surveys the current state of immutable data in Ruby, JavaScript, and Python, comparing and contrasting it to Clojure.

Having troubles supporting huge ACLs? Got your security rules spreaded across the whole app? Unsure if you permissions are getting applied properly? Say hi to Protector – the HQ of your defence line.

Let's see how to use all modern things like strong_parameters and CanCan keeping things centralized, clean and testable. And even more – how to use the security layer as an essential meta to DRY your business logic.

...but do not let it hit the fan.

Errors are the nightmare of every programmer. Talking about them leads to passionate and sometimes heated discussions (and maybe to some trolls) and although programming languages date back to more than 60 years, nobody can tell you what is the best way to deal with those &#@!& errors.

Return codes, exceptions, custom data types, warnings, function incompleteness status codes, …, I will present an aerial view of how various languages deal with these errors (C/Ruby/Python/Haskell and maybe Go). Most of the concepts I will be presenting will be applicable to many programming languages (as a lot of them share identical concepts) and code examples will be mainly written in python.

However, let's be realistic: I will not fix your errors, but I will give you some insight on how to train them.

Creating a cloud service is becoming easy with open source tools. However running a platform that provides mission-critical and hardware-intensive services is a challenging task. Platforms are driven by a large number of distributed computers, so it is critical to automate all operations that are possible.

I will introduce you to a lightweight virtualization technology LXC that lets you securely start a new virtual machine in a matter of seconds and with minimal footprint. I will give practical examples on how to automatically provision new physical and virtual machines using Ruby and Chef. Finally, we shall see what Docker brings to the table. These technologies can be used to build and deploy software and platforms in the cloud.