Merry Functional Christmas

4 min read


By Bendik Solheim


December 24, 2019

You are now reading the last of our 24 blog posts on functional programming. We hope you have enjoyed our functional advent calendar, and maybe even learned something new. We have tried to keep a balance between introductory and slightly more advanced posts to make sure most people can find something interesting to read. Believe me – this ain’t as easy as it sounds!

This last post is a bit different from the 23 previous ones. There will not be a single theme this time. Instead, we have collected some of the presentations on functional programming that we have enjoyed the most, and remember the best. They have different themes, but are all enjoyable and enlightning. You might have seen some of them before, but hopefully you’ll find at least one you haven’t.

Happy holidays, thanks for joining us, and enjoy the talks!

Simple Made Easy – Rich Hickey

Link: infoq.com/presentations/Simple-Made-Easy

Length: 60 minutes

"Rich Hickey emphasizes simplicity’s virtues over easiness’, showing that while many choose easiness they may end up with complexity, and the better way is to choose easiness along the simplicity path."

Propositions as Types – Philip Wadler

Length: 40 minutes

"The principle of Propositions as Types links logic to computation. At first sight it appears to be a simple coincidence---almost a pun---but it turns out to be remarkably robust, inspiring the design of theorem provers and programming languages, and continuing to influence the forefronts of computing. Propositions as Types has many names and many origins, and is a notion with depth, breadth, and mystery. Learn why functional programming is (and is not) the universal programming language."

Functional Principles for Object Oriented developers – Jessica Kerr

Length: 60 minutes

"How is an expert OO developer to improve on their craft? By learning from other paradigms! These six principles of the functional style also apply to OO. Some are part of good practice already; some express patterns both old and new; all give us different ways of thinking about problems. For developers without expertise in functional programming, examples in Java and C# provide new techniques for writing clear, quality code."

Parsing lexical ambiguity with Elm and expressive types – Emma Tsujimoto Cunningham

Length: 20 minutes

"Parsing lexical ambiguity in natural language has always been a tricky endeavor, both from the perspective of formal linguistics as well as natural language processing. In this talk, we'll consider one of the canonical examples from linguistics, the "Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo." sentence from Dmitri Borgmann's 1967 "Beyond Language: Adventures in Word and Thought.""

The Power of Composition – Scott Wlaschin

Length: 60 minutes

"Composition is a fundamental principle of functional programming, but how is it different from an object-oriented approach, and how do you use it in practice? In this talk for beginners, we'll start by going over the basic concepts of functional programming, and then look at some different ways that composition can be used to build large things from small things. After that, we'll see how composition is used in practice, beginning with a simple FizzBuzz example, and ending with a complete (object-free!) web application."

Why Isn't Functional Programming the Norm? – Richard Feldman

Length: 25 minutes

"Richard Feldman explores the reason why functional programming hasn’t taken over despite its advantages."

Functional Composition – Chris Ford

Length: 40 minutes

"Chris Ford demonstrates that music theory can be delightfully represented as code. He shows how to make music starting with the basic building block of sound, the sine wave, and gradually accumulates abstractions culminating in a canon by Johann Sebastian Bach. Examples will be live-coded in Clojure."

Communicating in Types – Kris Jenkins

Length: 40 minutes

"Modern type systems have come a long way from the days of C and Java. Far from being nit-pickers that berate us for making mistakes, type systems like the ones found in Haskell, PureScript and Elm form a language in themselves. A language for expressing high-level ideas about our software to our colleagues and to the computer. A design language. In this talk, we'll take a look at the way the right kind of type signatures let us talk about software. We'll survey how to state our assumptions about the domain we're coding in and how each part fits together. We'll show how it can highlight problems, and surface opportunities for reuse. And most importantly, we'll see how types can help you communicate to your coworkers, and to future maintainers, with little effort. You've probably heard the phrase, "programs are meant to be read by humans and only incidentally for computers to execute." Come and see how a modern type system is about communicating ideas to humans, and only incidentally about proving correctness."