In the last few days, the question of encryption, and whether governments can and should force companies to reveal customers’ data, has become big news. Apple has announced that they will not make it possible for the US government to read the contents of a terrorist’s iPhone, even thought that might provide clues to the shooting in which they participated, and to others connected to that crime. But is it a wise idea to give government access to all of our data and our communications? What implications does this have for government, for technology, for privacy, and for democracy? In this talk, Ron Rivest describes these issues, and considers whether granting such access to governments is more or less secure.
In theory, programmers spend lots of time developing new software. But in practice, developers spend a great deal of time debugging, trying to figure out why their code doesn’t do what they expect. The problem is that most debuggers operate similarly to how debuggers did 20, 30, or even 40 years ago. In particular, there’s no way to run a program backwards; part of debugging means that you need to catch the problem as the program runs, and then examine the state. In this talk, George Hotz introduces the idea of “timeless debugging” — in which the debugger knows how to unwind history, letting you backward as well as forward.
If you have a popular Web site, then you’ll realize (sooner or later) that the static content can and should be offloaded to a third-party service, known as a “content delivery network” (CDN), that specializes in getting content to users as quickly (and locally) as possible. Netflix also used CDNs for some time — but over the years, they have moved away from using third-party CDNs, and in favor of using their own, highly scaled, solution. Why and how did they make this change? How did this affect Netflix and its users? In this talk, Prasad Jonnalagadda describes the architecture that Netflix adopted, and the implications that this has had on the company and their technical teams.
People in the software industry are constantly talking about productivity. We use languages that will make our developers more productive. We use techniques, such as agile, which are supposed to deliver more value in less time. Some companies rank and pay developers based on their productivity — or outsource overseas because those developers are seen as more productive. But just what does “productive” mean, and how do we measure it? In this Webinar (without video, but with slides), Steve McConnell discusses this issue, and what it means for the software industry.
A very large number of us use open-source software every day. Many also participate in open-source projects. But if you maintain an active open-source project, then you’re dealing with other people’s code on a very regular basis. How do you handle this? How do you manage a large number of commits, or pull requests, or bugs, or feature suggestions? When should you define, or enforce, code standards? And what sorts of documentation standards shoudl you put in place? In this talk, Barak Michener shares his experience running a number of open-source repositories and projects. If you are thinking of managing a new open-source project, or becoming an active participant on an existing project, then this talk will help you to consider how to scale your software — not in terms of efficiency, but rather in terms of people, community, and contributors.
In machine learning, we train a computer to find correlations in our data — correlations that we might not find ourselves, or that would be too complex and time-consuming for a human to do. When you engage in a machine-learning project, you need to ensure that your data is reliable, and then choose an appropriate model. Then you need to check your model. It turns out that if you use Python, doing this sort of analysis is fairly straightforward. In this talk, Tenn Leeuwenburg provides a tutorial in machine learning using Python, talking about models, data, neural networks, and the appropriateness (or not) of certain kinds of models to particular situations.
Increasingly, Web sites want to be secure and encrypted. It doesn’t matter if you’re running a huge e-commerce site or just a lowly blog; the trend is clear, that having an HTTPS-encrypted site is a good thing to do. If that’s the case, then why don’t more people do it? Part of it is the cost — to have a secure site, you need to get a certificate from a (potentially expensive) certificate authority (CA). Let’s Encrypt is a new service that aims to make it easy and free to set up an HTTPS-powered site. In this talk, Josh Aas describes Let’s Encrypt — the motivations, the technology, and the issues remaining before HTTPS can be universally available.
“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.
Elections are a big deal in democratic countries — and people often wonder why they cannot yet vote on the Internet, or why voting cannot be more heavily computerized. But of course, there are many reasons for this, among them issues of security, verification, and privacy. Researchers have been thinking about these problems for quite some time, considering how we might be able to make electronic voting more secure, verifiable, and private than is current the case. In this talk, Vanessa Teague describes some of the technical challenges, and potential solutions, associated with electronic voting.