Time: 1 hour
“Systems programming” is a category of programming that requires high speed, demanded by such applications as operating systems, network servers, and databases. For many years, and even today, C is the go-to programming language for such work — but over the years, a growing number of other languages have been joining this space, most notably C++, and more recently D, Go, and Rust. What do each of these languages have to offer, and what do the languages’ designers prioritize in their designs? This panel brings together Bjarne Stroustrup (C++), Rob Pike (Go), Andrei Alexandrescu (D), and Niko Matsakis (Rust) to discuss what they think about programming languages, language design, community, and future directions.
So you want to add up a bunch of numbers, eh? Fine, but what’s the fastest way in which you can do this? What about if you want to parallelize your solution? What pitfalls will you encounter, and how can you avoid them? In this talk, Guy L. Steele takes us, slowly but surely, though a number of different ideas, strategies, and concepts having to do with parallel programming, and considers the implications of them — regardless of the language you’re using.
Cascading Stylesheets (CSS) is the way in which we describe the design and layout of Web pages. But is CSS a programming language, or something less than one? And have those boundaries changed over time? And what does this mean for the people creating and modifying stylesheets; what skills do they need to have? In this talk, Chris Eppstein describes what CSS has been, is, and will be, and how this will affect front-end design.
Do you use design patterns in your code? Probably — but that doesn’t matter, because the term “design patterns” probably sets you on edge so much that you haven’t stopped to consider whether you’re using them, and what advantages they might give you. It turns out that design patterns make it easy for you to communicate with other developers, to reason about the way in which you’re architecting your code, and to take advantage of the thought that many others have put into certain ways of developing software. In this talk, Jeremy Clark describes the reasons for learning design patterns, and then describes several of the most common ones that you’re likely using already, even without knowing it.
Additional materials: http://www.jeremybytes.com/Demos.aspx#LLDP
The Go language has become extremely popular in the last few years. This highly parallel, open-source language sponsored by Google is a systems language, meaning that it’s meant to be used for high-performance operations where C and C++ currently rule. As Go has matured, developers have found that certain practices make it easier to write and maintain their programs. In this talk, Rob Pike proposes a number of “Go Proverbs,” which should help to instruct, direct, and influence developers as they go about designing and implementing their software in Go.
Rust is a new programming language, aimed at making systems programming reliable, even when dealing with concurrency. Rust, whose development is sponsored by the Mozilla foundation, is gaining many fans who have not previously worked with static, compiled languages. What is it like to work with Rust? And what does it offer that other languages can’t or don’t? In this talk, Alex Burkhart tries to answer these questions, including why the Rust community continues to grow, providing support to newcomers.
Which is better, dynamic or static typing? For many years, this question has divided programmers, often bitterly. What are the advantages (and disadvantages) of the different approaches of typing, and how can we advocate for an approach without being blind to the trade-offs associated with that approach? In this talk, David Greenberg surveys a number of languages, approaches, and trade-offs, and how we can think about static vs. dynamic typing without getting into crazy arguments. Moreover, he describes how static typing can be seen as a benefit, rather than a straitjacket, as many dynamic-language aficionados might believe.