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.
For years, we’ve heard that in the future, our computers will be built from subatomic particles, using the rules of quantum mechanics. Things will run faster, in parallel, at lower cost… but to be honest, I’ve usually chalked this discussion up as fantasy, or something that we might, one day, see happen, but that I won’t see in the near future. However, it turns out that quantum computing is an active area of research, one in which there have been some promising results. In this talk, William Oliver tells us about the state of quantum computing, what sorts of problems it can (or might) be used to solve, and what the challenges are moving forward.
Security has always been an important consideration for Web developers. However, in the last few years, many sites have been pushing (or been pushed) to use only HTTPS (a secure version of HTTP) for their site. PCI regulations effectively require that a site only use HTTPS, and large sites such as Google and Facebook encourage (and sometimes demand) that a site refuse unencrypted HTTP requests. This means that many sites which could previously ignore the calls for HTTPS now need to use and install it. In this talk, Nick Sullivan introduces the ideas behind HTTPS, and walks new developers/administrators through the process of making an nginx-backed site HTTPS-compliant.
Computing architecture, while improved over the last few decades, hasn’t fundamentally changed. What would happen if we took all of our modern advances, and used them to create a new type of architecture? Well, some engineers have done that; “the machine” is a project from Hewlett Packard Enterprise, which aims to demonstrate just that sort of thing. How does it work, and how is it different from other computer architectures? In this talk, Keith Packard introduces The Machine, and describes how it differs from other computer architectures in hardware and software.
Alan Turing is one of the most famous early computer scientists: He provided us with many of the theories of computation (e.g., so-called “Turing machines“) that are seen as fundamental to computer science. But beyond the headlines, stories, and even a movie about Turing’s life, there is much that many of us don’t know. In this talk, Demont Turing — Alan Turing’s nephew — provides insights, depth, and stories about his uncle, including both professional and personal information.
One of the great advances in Python over the last few years has been the maturation of generators — starting as an alternative way to create an iterator, then as the basis for coroutines, and now as the basis for asynchronous programming. But just what are coroutines, and how do they allow us to write asynchronous code? In this talk, A. Jesse Jiryu Davis walks us through the creation of a simple HTTP client, first without coroutines, then with them, and then using asynchronous techniques. If you’ve often wondered how these additions to Python might be useful in your work, or how the asynchronous additions to Python 3 are used, this talk should be of great interest to you.