Programmers write code, and then run that code. But what does your programming language do in order to turn your program into something that runs? In this talk, Nick Heiner shows what you would need to do in order to write a new programming language. In so doing, he describes many of the things that modern languages have to do, and how they can go about doing it. If you’re ever wanted to know more about the implementation of a language without having to endure the pain of creating it, this talk should be quite interesting for you.
When people start to learn about functional programming, they often encounter the term “monad.” And then they try to understand what monads are, and get frustrated and/or confused. In this talk, Pawel Szulc tries to address this fear and confusion regarding monads by asking what they are — and more importantly, what questions we should ask in order ot understand them more easily. If you’ve ever wondered what monads are, or why you should care about them, then this talk should be quite helpful.
Web security is an important consideration for any application, but as JavaScript becomes an increasingly vital part of the Web, we need to consider the specifics of JavaScript. One way to check the security of your applications is using “penetration testing,” also known as “pentesting.” In this talk, Prasanna Kanagasabei describes his experiences as a pentester working with JavaScript, and describes the challenges and issues that he has had in trying to check JavaScript-based applications — and the things he wishes the engineers who had written those knew when writing the apps.
Functional programming continues to grow in popularity — but in many cases, the languages we’re using for our functional programming are quite old. As such, they often use a combination of ideas from different backgrounds, traditions, and older languages. In this talk, John A De Goes describes the problems that he sees with current functional languages, and what he would want to see in newer ones. Even if you’re not interested in functional programming, this wish list and consideration of what should (and shouldn’t) be in modern programming languages is both interesting and a great deal of fun.
So, you’ve got a lot of data. You might even say “big data.” You want to analyze it, and so you turn to Python and the SciPy stack. But you might also want to benefit from a relational database, such as PostgreSQL — either because the data is already in there, or because it’ll be useful to take advantage of some of PostgreSQL’s features. In this talk, Josh Berkus shows us how we can use PL/Python, running inside of the database — thus avoiding the need to transfer data from the database to Python. If you’re doing data science, using Python, or using PostgreSQL, then this talk will show yo how to combine these tools for fast and flexible open-source tools that help you to do great data science.
IPython notebook (aka Jupyter) is a well known, Python-based system for working with and collaborating on data science. But sometimes you don’t want to have people work on a data-science project, so much as be able to review certain aspects of that data. In other words, you want to create a small application that lets people review and play with limited aspects of the data. As Andrew Campbell explains in this talk, it’s now possible to create and use widgets from IPython, to create useful and interesting applications — streamlining and speeding up the process even more than before.
Racket is a minimalist version of Lisp — and more specifically, of Scheme, a simplified, minimalist (but quite powerful) version of Lisp that is designed for programming language experimentation and education. Typed Racket, as the name implies, allows you to have some enforced type constraints on your Racket programs. In this talk, Mark Farrell introduces Typed Racket, shows how we can add type constraints — and most importantly, why we would want to do that. If you’re interested in Lisp, programming languages, or the trend we’re seeing of dynamic languages (such as Python, Ruby, and JavaScript) starting to take on optional type systems, then this talk will be of interest to you.
Erlang is a functional language, designed for systems that cannot scale and that are highly parallelized. Why has interest in Erlang risen in the last few years, and why are people using a language that explicitly avoids state, objects, and threads in favor of functional techniques and processes? In this talk, Steven Proctor introduces Erlang, describing why it works the way it does, and how you can use it for better, faster, and more reliable software systems.
Software developers love to talk about “abstraction” as an important principle. But what’s the point of abstraction? How does it help us to write, and create, software that easier to write, extend, and modify? How can we use the principles of abstraction to think in new and better ways, to solve bigger problems, and write better software? In this talk, Gershom Bazerman talks about abstraction — not just from the perspective of the Haskell language, but from programming in general.