Category Archives: Programming languages

[Video 409] Nick Heiner: Make Your Own Programming Language!

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.

[Video 406] John A De Goes: The Next Great Functional Programming Language

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.

[Video 403] Mark Farrell: Introduction to Typed Racket

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.

[Video 402] Steven Proctor: Introduction to Erlang

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.

[Video 374] John Cinnamond: Softly, softly typing

Ruby is a dynamically typed language. This means, generally speaking, that objects have types, but variables don’t. While this makes for a very easy-to-use programming language, it also means that there isn’t any way for the language to know, or enforce, types when they are passed to operators or methods. It has been proposed that Ruby 3 will include a “soft typing” system, letting developers include optional typing on their variables. In this talk, John Cinnamond demonstrates the use, and implementation, of a soft-typing system in an extremely simple language. If you’re curious about the future of typing in Ruby, or of how type systems are implemented, you’ll enjoy this talk.

[Video 373] Erika Heidi: Getting Ready for PHP 7

PHP is one of the most popular languages for Web development, Many programmers think that PHP has gone out of favor for serious applications — but remember that WordPress powers a huge proportion of the Web, and it’s written in PHP. (Plus, you have companies such as Facebook that are using languages related to PHP.)  PHP 7 includes a huge number of optimizations and language improvements. If you’re a PHP developer, then you’ll definitely want to watch Erika Heidi‘s talk, in which she describes the changes included in this latest version,

[Video 372] Maria Geller: The ClojureScript Compiler – A Look Behind the Curtains

ClojureScript is a version of the Clojure language that compiles into JavaScript — and thus can be run inside of a Web browser. How does ClojureScript work? How does the compiler turn one language into another, and then work around the limitations inherent in a browser environment? In this talk, Maria Geller demonstrates these processes, giving us insights into Clojure, ClojureScript, JavaScript, and compilers in general.

[Video 369] Aaron Patterson: Inside Ruby’s VM — The TMI Edition

How does Ruby work? That is, the Ruby virtual machine — often known as the MRI — is what runs the bytecodes into which our Ruby program is translated. But how does the Ruby VM actually do what it needs? And what does the Ruby VM do to improve the efficiency of our code?  In this talk, Aaron Patterson provides a gentle introduction to VMs in general, and the Ruby VM in particular. If you’re a Ruby developer, and have ever wondered how your code is executed, or why Ruby works the way it does, this talk will be of great interest.

[Video 367] Joe Conway: Fun with Functions, by Example

Functions are one of PostgreSQL‘s most powerful and least-used features. You can invoke functions, but you can also write functions in a variety of languages. How do PostgreSQL’s functions work?  How are the languages different from one another?  How do you create anonymous functions? And what are the best practices for function creation?  In this talk, Joe Conway answers all of these questions, and more, providing a deep dive into the functions that we use, and those that we create, providing a great deal of insight into the process for PostgreSQL users old and new alike.

[Video 365] James Adam: Why is nobody using Refinements?

Several years ago, a new proposal made the rounds in the Ruby community. “Refinements” were proposed as a way to modify an existing class, but without the unfortunate (and potentially dangerous) side effects of monkey patching. The Ruby community discussed and debated refinements, and when they were finally included in Ruby … well, it seems that almost nothing happened, because no one really used them. In this talk, James Adam asks why no one is using them. He describes refinements, and then points to reasons why they might be interesting and/or useful, and then discusses why they aren’t in common use.