When working in C++ I tend to solve every problem with a C++-shaped hammer. When working in Javascript, every problem looks like a Javascript-shaped hammer. And so on. Getting back to thinking about the problem first, and the implementation second, is a difficult mind shift. So I set about re-writing the same code in each of the 16 different languages in which I’ve professionally developed. This talk will take you on that journey of discovery highlighting many ideas to expand your own thought processes.

• Ada
• General Programming
• C++
• JavaScript

The usage of Rust started as an experiment at Sentry but became a non negligible part of our infrastructure. This is lessons learned, what works and doesn't and what we think is going to happen in the future.

• Rust

Google's Protobuffer is more than just a data interchange format: along with the use of templating and a code generation tool, it can be the cornerstone of a company's polyglot software development strategy. In this presentation we will see how we are implementing it at Vente-Privee.com and the benefits we are already receiving.

• Protobuffer
• Integration

Spoon theory is a metaphor about the finite energy we each have to do things in a day. While a healthy, advantaged person may not have to worry about running out of ‘spoons,’ people with chronic illnesses or disabilities and members of marginalized groups must consider how to ration their energy to get through the day. Understanding this can help companies lessen the everyday burdens on their underrepresented employees, leaving them more spoons to do their best work, avoid burnout and lead fulfilling lives.

• Programming
• Psychology
• Best Practices

I have been using Haskell in production at Checkpad MED, TramCloud and other many projects for more than 5 years and would like to discuss the advantages and challenges discovered during this time. We will look at first principles on structuring, building and testing Haskell applications at scale, discuss interfacing and deployment of microservices, performance and practical considerations like debugging, tooling support and IDEs.

• Haskell

Serverless might change the industry in a big way. Miss it out and you soon might be out of business, as your competition will save huge infrastructure money, developers time and will scale better than you. Presentation is an introduction, but with hard technical insights on how the serverless is really different what classic and microservices design.

• Serverless
• Architecture
• Infrastructure

Lua has many different implementations and derived languages (among others, these include LuaJIT, TypedLua, Starlight, Ravi, Terra and Moonscript). In this talk we'll compare standard Lua with the popular LuaJIT, known especially for its speed. The topics covered include: an introduction to Lua and LuaJIT; compatibility and code styling differences; use cases; and issues you should be aware of.

• Lua
• LuaJIT
• Virtual Machine

Across the stack at Improbable we have components written in ~5 different languages, and we rely heavily on Google's protocol buffers to tie them all together. In this talk we'll discuss what protocol buffers are, how we use them at Improbable, and some of the extensions we've built on top of protocol buffers to add validation, logging and how it forms the basis of our custom ORM layer.

• Integration
• Infrastructure

Congratulations! You’re the technical lead on your next project! But now what? The lead can be responsible for requirements, architecture, communication with clients or managers, or divvying work amongst the team–and that's just what they tell you about ahead of time. We’ll talk about how to oversee the project without losing sight of the day to day, how to motivate your team without overstepping your bounds, and tactics to deal with issues you might not anticipate, but will almost certainly encounter.

• Technical Management

We all have been in situation when we were in one platform and had to move to another. While it’s relatively easy to build a new web app in React, migrating a service that’s constantly changing and used by millions of people is a much more complicated challenge. It’s like changing the engines of an airplane while mid-flight. The talk is about techniques we tried and challenges we faced while migrating to React at Pinterest.

• React
• Architecture
• Infrastructure
• Best Practices

During the last months I've written from scratch Barrel is a modern document-oriented database with master-master replication targeting micro-services with a RESTful API written in Erlang. This talk will describe the different challenges we faced in writing a database, from binding C code in Erlang, to write a complete SQL Engine. This talk will also describe the different patterns used for Reads and Writes concurrency but also continuous automated indexation of the documents.

• Erlang
• Database
• SQL
• API

In 2013, we decided to build our own programming language to fill a narrow but critical role in our technology stack. Four years later, this talk dives into our reasons for doing so, our experiences as a small team in running production code through a compiler that we were writing at the same time, and what it took to ensure the stability of our domain-specific language and the proficiency of its users.

• Programming Language Design

Homoiconicity is a word the Clojure community likes to use heavily. It’s a cool property of the Clojure language: it means that code can be treated as data. We as computer people are used to handling data: we can visualise it, analyse it and even generate it. What does it imply if we can do the same things with our Clojure code? I will investigate this question through a series examples and hopefully help you understand this abstract concept better.

• Clojure

Most non-scripting languages are faster than Ruby (Rust: tremendously so), but few (Crystal?) can match its optimisation for developer happiness and productivity. Let’s try to gauge Ruby’s chances when it comes to matching modern performance expectations: Are the changes in recent CRuby versions significant? Can JRuby bring enough JVM performance? And – to address the titular Frankenstein – how easily can we harness the power of Crystal, Rust, C or even assembly from within our Ruby applications?

• Ruby
• Crystal
• Assembly
• C
• JVM

• Python
• ETL

Pony is a new language designed to make fast, concurrent programing simple. Its actor-based concurrency and advanced type system ensure programs are data race and deadlock free. We'll compare Pony to more mature technologies, starting with when you shouldn't use it, when you should, and what your alternatives might be. You'll learn about Pony's design philosophy, how the actors simplify writing safe code and more. You'll leave understanding what Pony is and if it's something you might use.

• Pony
• Actor-based
• Programming Language Design

• OSS
• Node

Writing programs in a high-level language such as Ruby, with extensions written in C, is probably the earliest form of polyglot. In GraalVM we're rethinking this from first principles and actually interpreting C extensions using the latest in virtual machine technology.

• Ruby
• Virtual Machine
• JVM

This talk will introduce ZetaVM, a new platform designed to enable anyone to create their own programming language. ZetaVM is designed primarily for enthusiasts rather than for industry, and takes a fresh look at the foundations on which modern VMs are built. Planned features include a simple text-based bytecode format, the ability to introspect running code and generate new bytecode at run-time, a functional/compositional approach to sound and graphics, as well as GPU-based acceleration using an SPMD programming model.

• Programming Language Design
• Virtual Machine

Elixir is a functional language which runs on the Erlang VM. The unique design of the VM makes the language a great choice for writing applications which does networking and other forms of IO. Although Elixir excels in many areas, sometimes you need to do something that requires a lower-level language. In this talk we're going to discuss how Rust and the Rustler project can make interacting with native code both safer and easier for the programmer.

• Erlang
• Elixir
• Rust
• Integration

Solidity is a programming language to create a smart contract on Ethereum blockchian. Smart contract enables you to codify how monetary value is transferred. Makoto is the creator of BlockParty, a meetup management blockchain app (with a twist) built on Ethereum, and have used to manage real world events. He will show you how writing smart contract enforces developers to write a code in the unique way which you don't think about writing code in any other languages.

• Solidity
• Blockchain
• Ethereum

“What’s the fastest way of doing this?” - you might ask yourself during development. Sure, you can guess, your intuition might be correct - but how do you know? Benchmarking is here to give you the answers, but there are many pitfalls in setting up a good benchmark and analyzing the results. This talk will guide you through, introduce best practices, and surprise you with some unexpected benchmarking results. You didn’t think that the order of arguments could influence its performance...or did you?

• Best Practices
• Benchmarking

Today, mobile web traffic is greater than desktop traffic. Many of us didn't think this would be possible, 10 years ago. Most of our tools were built around desktop web has been long obsolete, but they still haunt us in our transition to mobile web development. With the evolution of JavaScript (es6 and beyond), along with React, we are getting closer to native development. With the benefit of mobile web (ubiquitous and cross platform), along with native-like experience, what will the future be like?

• Mobile
• JavaScript
• React
• Swift
• React Native

Graal is a new just-in-time compiler for the Java Virtual Machine with support for the Truffle polyglot framework. Integrated language runtimes include JavaScript, Ruby, and R. Additionally, it supports LLVM-based languages such as C, C++, Go, and Rust. Graal enables seamless language interoperability while also providing world-class performance for each individual language. A demo will show how JavaScript, Java, Ruby, R, and C can work together in a single web application running in one VM!

• Virtual Machine
• Programming Language Design
• JavaScript
• Ruby
• R
• LLVM
• C/C++
• Rust
• Go

Even if polymorphism is one of the first concepts we learn as developers, it is actually a very profound notion in software construction. In this presentation taking C++ as an example, you’ll see that polymorphism can itself take a wide variety of shapes and in particular different moments of resolution. And more importantly, how to pick the one that is most adapted to your design.

• C++
• Programming Concepts

Very few desktop apps expose APIs. In part, the use cases are just too obscure to bother with. But in part, building APIs requires us to bridge the web and the desktop, and that's not very easy. But it can be done. And you can do it too. One of my first jobs at Screenhero was to build an API that allowed Slack to control our desktop application. Journey with me through Screenhero’s API and see how we blended Ruby, Erlang, C, JavaScript, and sheer naïveté, all so you could type `/hero` into Slack and watch magic happen.

• Ruby
• JavaScript
• Erlang
• C

The programming paradigm we work in shapes every aspect of how we craft our code, providing a model of what a program is, and what it can and should be. In this talk, we’ll explore the connections between the programs we write, the languages we work in, and the paradigms we use, and try to get some historical and philosophical perspective on the familiar paradigms of imperative, declarative, object-oriented, and functional programming, focusing on the points where they intersect and collide. We’ll discover the valuable lessons different paradigms can teach us, and find motivation to stop arguing with our fellow coders about which is superior, and instead encourage each other - as individuals and a community - to pursue poly-paradigm programming.

• Python
• JavaScript

Web engines have evolved into sophisticated virtual machines. Millions of developers build for the web platform, and the resulting code runs on everything. Servo aims to be far more than a web browser engine by allowing developers to embed it in their own applications and by building a runtime based on web technology. In this talk, Jack will cover motivations, use cases, and potential new programming models.

• Rust
• Servo