You are viewing content from a past/completed QCon

Track: 21st Century Languages

Location: Pacific DEKJ

Day of week: Tuesday

In the same way that it is hard to imagine thinking without language, it’s nearly impossible to conceive of programming without programming languages. Programming languages are so integral to the work that we do as technologists that we often do not realize that similar to a library or framework, programming languages are just tools- subject to the design tradeoffs and considerations that any technology faces.

At their core, programming languages help us express a program. What are the programs that we have historically wanted to be able to express and haven’t succeeded at? How and why do currently available languages and language features fail at expressing certain programs? What are the programs that no programming language has expressed well yet? Why do these programs matter? How will being better able to express these programs change the potential future of technology?

In this track, we’ll explore contemporary programming languages, how they are designed, and their goals and visions for the future of programming. We’ll touch on some of the trickiest aspects of programming (memory management, concurrency/parallelism, etc) and dive deep into how contemporary languages are building features to make expressing these programs more productive, safe, and ergonomic. Along the way, we’ll examine how the interplay of governance and community structures play a critical role in the language design process.

Track Host: Ashley Williams

Core Rust Team @RustLang

Works on the Rust Programming Language and WebAssembly for Mozilla. Previously, wrote and maintained Rust and Node.js backend services at NPM, Inc. Rust core team member and leads the Rust community team. Founded NodeTogether educational Initiative and member of the Node.js Board of Directors. Invited expert to TC-39 representing the language learnability.

10:35am - 11:25am

WebAssembly: Neither Web Nor Assembly, But Revolutionary

A revolution has begun. WebAssembly is a new, efficient and safe bytecode designed and maintained by most of the major players in tech: Google, Microsoft, Apple, Mozilla, Intel, LG, and many others. This unprecedented collaboration to standardize a new, cross-platform instruction set has opened the door to a future where any language can efficiently target the web—but it’s not actually just for the web! WebAssembly is so revolutionary it’s already being used outside of the web, even being integrated into operating systems, running on servers, powering blockchain compute platforms, and more.

In this talk learn what WebAssembly is and what it isn’t, while discussing the design decisions and compromises made to meet these goals.

Jay Phelps, Chief Software Architect @ThisDotMedia

11:50am - 12:40pm

Kotlin: Write Once, Run (Actually) Everywhere

Kotlin used to be described as a new language for the JVM which aims to fix some of the pain points of Java. But more recently Kotlin is also a language for the web, iOS, desktop, embedded, and just about anywhere else code can run. JetBrains, the creators of Kotlin, have placed a strong emphasis on targeting multiple platforms in how the language is compiled, its language features, and the standard libraries. This talk will be an exploration of the Kotlin language, how it compiles to run on more than just the JVM, and whether it can fully pull off the multiplatform trick allowing a single codebase to run everywhere.

Jake Wharton, Android Engineer @Google

1:40pm - 2:30pm

The Most Secure Program Is One That Doesn’t Exist

Rust is a programming language that started with the explicit goal of preventing segfaults and guaranteeing thread safety to create a fearlessly concurrent systems language. The compiler enforces type- and memory- safety to achieve this. There’s a significant overlap between critical security bugs and memory vulnerabilities, so code written in Rust is more secure. But that’s only half the story. Can a language mitigate side-channel attacks? How can we integrate formal methods to prove implementation correctness? This talk will give an overview of how Rust’s design gives security guarantees and discuss goals and visions for the future.

Diane Hosfelt, Research Engineer @mozilla

2:55pm - 3:45pm

Go - A Key Language in Enterprise Application Development?

Go’s popularity in the last few years is hard to miss. It has jumped up in the Tiobe index and is holding steady.  The language has had a significant impact on the startup scene due to its simplicity, speed and enabling productivity in engineering teams. Large companies are starting to take notice. We also see a huge amount of community involvement in Go. If you have lived through the growth of Java in the late 90’s, this feels a bit like `déjà vu.’  In this talk, I will go over the Go language design and talk about why Go matters in the age of multicores and cloud-native computing.

Aarti Parikh, Engineering Manager @PayPal

4:10pm - 5:00pm

21st Century Languages Panel

Join track hosts Ashley Williams (Core Rust Team member) as she pulls together an interlanguage working group to discuss our software languages. There's no Golden Hammer come hear an active discussion on picking the right one for your use case! 

Ashley Williams, Core Rust Team @RustLang
Jay Phelps, Chief Software Architect @ThisDotMedia
Aarti Parikh, Engineering Manager @PayPal
Diane Hosfelt, Research Engineer @mozilla
Bryan Cantrill, Co-Creator DTrace, Co-Founder Fishworks Sun Microsystems, & Currently CTO @Joyent

5:25pm - 6:15pm

3 Things I Wish I Knew When I Started Designing Languages

When I first sat down to design a language I had a rough time.  I sat for months in front of a blank screen trying to invent, ex nihilo, a syntax that looked sufficiently different from anything I had ever seen. Isolation wasn’t working.  But every time I talked to someone about what I was working on they spun me far off course, either with scorn (e.g. “hahahaha, what do you need a new language for?”) or with opinions (e.g., “it needs to have promises and futures”).  Finally, after years of labor and dissemination, my first language never really gained more than one user. I had failed; I was discouraged; I wished I had never begun.

That was seven years ago.  Today, that language (called `Dedalus’) still permeates my life in every way.  Sure, it has an uncreative syntax and rigid rules that sometimes make it difficult to express things that are easy in more familiar languages. Sure, it is essentially impossible to sell to users -- even my own team members and students!  Nonetheless, I use Dedalus every day. It helps me to write useful programs, but more importantly, it frames how I am allowed to think about its target domain.  When I use Dedalus to model a system I thought I understood, I often learn something new.  It has created a scaffolding on which every piece of my subsequent research hangs. That failed language is probably the most important success of my life.

In this talk, I hope to convince you that there is more than one reason to engage in language design and more than one way to do it.  I hope to communicate why someone would (and indeed many of us should) do something so perverse as to design a language that no one will ever use.  Along the way, I will share some of the extreme and sometimes obnoxious opinions that guided my design process.

Peter Alvaro, Asst Professor @UCSC, Researching Data-Centric Languages/Analysis Techniques & Worked on Failure Injection Testing @Netflix

Michael Kehoe, Architect of reliable, scalable infrastructure @LinkedIn


  • Modern Operating Systems

    Applied, practical & real-world deep-dive into industry adoption of OS, containers and virtualization, including Linux on.

  • Software Supply Chain

    Securing the container image supply chain (containers + orchestration + security + DevOps).

  • Modern CS in the Real World

    Thoughts pushing software forward, including consensus, CRDT's, formal methods & probabilistic programming.

  • Tech Ethics: The Intersection of Human Welfare & STEM

    What does it mean to be ethical in software? Hear how the discussion is evolving and what is being said in ethics.

  • Optimizing Yourself: Human Skills for Individuals

    Better teams start with a better self. Learn practical skills for IC.

  • Modern Data Architectures

    Today’s systems move huge volumes of data. Hear how places like LinkedIn, Facebook, Uber and more built their systems and learn from their mistakes.

  • Practices of DevOps & Lean Thinking

    Practical approaches using DevOps and a lean approach to delivering software.

  • Operationalizing Microservices: Design, Deliver, Operate

    What's the last mile for deploying your service? Learn techniques from the world's most innovative shops on managing and operating Microservices at scale.

  • Bare Knuckle Performance

    Killing latency and getting the most out of your hardware

  • Architectures You've Always Wondered About

    Next-gen architectures from the most admired companies in software, such as Netflix, Google, Facebook, Twitter, & more

  • Machine Learning for Developers

    AI/ML is more approachable than ever. Discover how deep learning and ML is being used in practice. Topics include: TensorFlow, TPUs, Keras, PyTorch & more. No PhD required.

  • Production Readiness: Building Resilient Systems

    Making systems resilient involves people and tech. Learn about strategies being used from chaos testing to distributed systems clustering.

  • Surviving Uncertainty: Regulation, Risk, and Compliance

    With so much uncertainty, how do you bulkhead your organization and technology choices? Learn strategies for dealing with uncertainty.

  • Languages of Infra

    This track explores languages being used to code the infrastructure. Expect practices on toolkits and languages like Cloudformation, Terraform, Python, Go, Rust, Erlang.

  • Building & Scaling High-Performing Teams

    Building, maintaining, and growing a team balanced for skills and aptitudes. Constraint theory, systems thinking, lean, hiring/firing and performance improvement

  • Evolving the JVM

    The JVM continues to evolve. We’ll look at how languages like Kotlin, Graal, Clojure, and Java are evolving the JDK. Expect polyglot, multi-VM, performance, and more in this track.

  • Trust, Safety & Security

    Privacy, confidentiality, safety and security: learning from the frontlines.

  • JavaScript & Transpiler/WebAssembly Track

    JavaScript is the language of the web. Latest practices for JavaScript development in and how transpilers are affecting the way we work. We’ll also look at the work being done with WebAssembly.