Category Archives: Programming languages

[Video 456] Scott Hanselman: JavaScript, The Cloud, and the Rise of the New Virtual Machine

It has often been said that JavaScript is the assembly language of the Web. But as JavaScript becomes an increasingly popular target for other languages (in the browser, or on the server) and as virtual machines make it easy, perhaps it’s time for us to think about what constitutes an operating system, and what it means to have a “computer” running a program. Emulation, and virtual machines, make all sorts of new architectures possible.  What is the role of the browser vs. the server? What can we expect to see as we move forward, given the ubiquity of JavaScript and VMs?  And what can we learn from classic computer architecture and languages as we move forward?  In this talk, Scott Hanselman discusses all of these topics.

Time: 1 hour

[Video 450] Sébastien Doeraene: Scala.js Workshop

JavaScript has often been described as the “assembly language of the Web.” Implied in this description is the notion that other languages can and should compile into JavaScript. We have seen examples of this, most prominently with ClojureScript. But Scala, a popular programming language that runs on the JVM, now has a version that compiles into JavaScript, as well: Scala.js. This talk, by Scala.js author Sébastien Doeraene, describes the aims of the project, how well Scala.js programs can interact with other JavaScript libraries and functionality, and what Scala’s typing does to improve the state of JavaScript programming.

[Video 442] Panel discussion: Rustlang , Golang, C++, Dlang

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.

[Video 428] Guy L. Steele: Four Solutions to a Trivial Problem

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.

[Video 427] Chris Eppstein: The expanding boundaries of CSS

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.

[Video 419] Jeremy Clark: Learn the Lingo — Design Patterns

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.

Time: 1:04

Additional materials:

[Video 417] Rob Pike: Go Proverbs

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.

[Video 415] Gaurav Seth: Inside Chakra

Chakra is Microsoft‘s JavaScript engine, and as of this month (January 2016), its core is now released under an open-source license. But what exactly does Chakra bring to the table? And how is it different from other JavaScript engines? In this talk, Gaurav Seth provides us a full picture of Chakra — from its origins to its current state of affairs, including licensing, technical capabilities, speed, debugging support, architecture, and future plans. If you’re interested in JavaScript — and let’s be honest, if you have a Web browser, then you should be interested — and would like to keep up on the latest in the competition among open-source JavaScript engines, then this talk should be of great interest to you.

[Video 411] Alex Burkhart: In Rust We Trust

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.

[Video 410] David Greenberg: Dynamic vs Static — Having a Discussion without Sounding Like a Lunatic

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.