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

2020 Tracks

  • Social Responsibility: Implications of Building Modern Software

    Software has an ever increasing impact on individuals and society. Understanding these implications helps build software that works for all users

  • Non-Technical Skills for Technical Folks

    To be an effective engineer, requires more than great coding skills. Learn the subtle arts of the tech lead, including empathy, communication, and organization.

  • Clientside: From WASM to Browser Applications

    Dive into some of the technologies that can be leveraged to ultimately deliver a more impactful interaction between the user and client.

  • Languages of Infra

    More than just Infrastructure as a Service, today we have libraries, languages, and platforms that help us define our infra. Languages of Infra explore languages and libraries being used today to build modern cloud native architectures.

  • Mechanical Sympathy: The Software/Hardware Divide

    Understanding the Hardware Makes You a Better Developer

  • Paths to Production: Deployment Pipelines as a Competitive Advantage

    Deployment pipelines allow us to push to production at ever increasing volume. Paths to production looks at how some of software's most well known shops continuous deliver code.

  • Java, The Platform

    Mobile, Micro, Modular: The platform continues to evolve and change. Discover how the platform continues to drive us forward.

  • Security for Engineers

    How to build secure, yet usable, systems from the engineer's perspective.

  • Modern Data Engineering

    The innovations necessary to build towards a fully automated decentralized data warehouse.

  • Machine Learning for the Software Engineer

    AI and machine learning are more approachable than ever. Discover how ML, deep learning, and other modern approaches are being used in practice by Software Engineers.

  • Inclusion & Diversity in Tech

    The road map to an inclusive and diverse tech organization. *Diversity & Inclusion defined as the inclusion of all individuals in an within tech, regardless of gender, religion, ethnicity, race, age, sexual orientation, and physical or mental fitness.

  • Architectures You've Always Wondered About

    How do they do it? In QCon's marquee Architectures track, we learn what it takes to operate at large scale from well-known names in our industry. You will take away hard-earned architectural lessons on scalability, reliability, throughput, and performance.

  • Architecting for Confidence: Building Resilient Systems

    Your system will fail. Build systems with the confidence to know when they do and you won’t.

  • Remotely Productive: Remote Teams & Software

    More and more companies are moving to remote work. How do you build, work on, and lead teams remotely?

  • Operating Microservices

    Building and operating distributed systems is hard, and microservices are no different. Learn strategies for not just building a service but operating them at scale.

  • Distributed Systems for Developers

    Computer science in practice. An applied track that fuses together the human side of computer science with the technical choices that are made along the way

  • The Future of APIs

    Web-based API continue to evolve. The track provides the what, how, and why of future APIs, including GraphQL, Backend for Frontend, gRPC, & ReST

  • Resurgence of Functional Programming

    What was once a paradigm shift in how we thought of programming languages is now main stream in nearly all modern languages. Hear how software shops are infusing concepts like pure functions and immutablity into their architectures and design choices.