You have probably heard of this mysterious language called Haskell. The Haskell code typically looks very different from what we are used to from other languages. The Haskell discussions and blogs mainly seem to center around types and some algebra stuff. Many attempting to learn the language find it befuddling to the point that they give up early in exasperation.

In this talk, I will take you into the mind of a typical Haskeller, and show you how she thinks about programs; how the holy trinity of types, functions, and algebras form the basis of all program design; how this leads to natural evolution of computational abstractions such as monads; how types can sometimes even “write” your programs for you; and how Haskellers manage to sleep more peacefully at night than most of us do!

Scala began its life as an experiment to “unify” object-oriented programming and functional programming. Martin Odersky believed that the differences between FP and OO are more cultural than technical, and that there was a room for beautifully unify various ideas from the two into one simple core.

How successful has Scala been in its goals? Is it the like “the grand unified theory of universe” or like the infamous “vegetarian ham”? [1]

In this talk, we will see just how Scala unifies various ideas – such as type-classes, algebraic data types, first-class modules, functions under one simple core comprising of traits, objects, implicits, and open recursion. We will how this unification unintendedly subsumes many concepts that require seprate features in other languages, such as functional dependencies, type families, GADTs in Haskell. We will see how this has given a rise to a new “implicit calculus”, which could lay a foundation for next generation of generic programming techniques.

We will see that this unification comes at a certain cost, wherein it leads to some compromises on both sides. However many of these trade-offs are particular to Scala (largely due to the JVM imposed restrictions). The goal of unification is still noble, and we need not throw the baby out with the bathwater.

[1]: https://twitter.com/bos31337/status/425524860345778176

Futures and promises are no strangers to most programmers. They have made their way into major mainstream languages, including but not limited to, Java, C#, JavaScript, and C++.

This abstraction however is typically dreaded due to the way they’re typically done. Most manifestations lead to the insidious callback hell, and some, like Java’s, are incredulously limited.

Why can’t we keep our simple, straightforward code, and still have the concurrency benefits of futures and promises?! Turns out we can. Functional programming is here to the rescue! We will see how the seemingly obscure abstractions like monads, delimited continuations allow us to do just that.

We will also go over some syntactic-transformation based approaches (basically, macros), such as C#’s async-await, and see how it compares with the functional approaches discussed earlier.

Of all the computational abstractions that functional programming has brought to the table, monads seem to be disproportionately more popular than the rest. (Or should I say, notorious?) The web is filled with monad tutorials, ranging from those using pure mathematics to explain the idea, to those using (half-baked) metaphors like burritos and space-suites. One might think this should make it relatively easy to grok monads. Unfortunately, many of these tutorials do a rather poor job, and do not help students gain an intuition for the idea. This has resulted in an unparalleled FUD around monads.

A part of difficulty people have when learning functional programming abstractions such as monads comes from the fact that, this new way of thinking involves looking for abstraction opportunities in places they’re not used to.

In this talk, I will start by presenting some seemingly unrelated day-to-day code examples. I will underline the problems common to all of them, and then we will all together derive a general abstraction applicable to all of them. If you can follow through till the last bit (and in my experience, most of the audience does), you have not only understood but essentially re-invented monads!