Lambda-Cast

Wrapping up our grand tour of functional programming we go into more depth about the benefits of a functional first language.

Tell us what you think at contact@lambdacast.com

Show Notes:
https://www.infoq.com/presentations/Simple-Made-Easy
https://www.infoq.com/presentations/Value-Values
http://l.facebook.com/l.php?u=http%3A%2F%2Fheeris.id.au%2F2013%2Fthis-is-why-you-shouldnt-interrupt-a-programmer%2F&h=5AQHAs9rP
http://fsharpforfunandprofit.com/

2: Overview of Functional Programming part 2

This time around we'll be talking over the core benefits of FP and why you might want to consider its use in your projects.

Tell us what you think at contact@lambdacast.com

Show Notes:
https://www.destroyallsoftware.com/talks/boundaries
http://blog.ploeh.dk/2015/08/17/when-x-y-and-z-are-great-variable-names/

3: Why FP?

This episode we discuss the ins and outs of higher-order functions. If you've never heard of them don't fear they're not as scary as they sound, in fact you're probably already using them!

LambdaCast

4: Higher-Order Functions

This time we tackle the thorny issue of how you get anything done when you're not allowed to change anything. If the idea of immutability seems strange or even impossible, then we've got you covered.

5: Immutability

To write a program is to deal with uncertainty. Sometimes it feels like there's nothing we can count on and null (or undefined) is as pervasive as any other construct in our languages. However this does not have to be! LambdaCast dives into the thorny problem of null, and more broadly the potential for values not to exist and offers up some alternatives.

Aaron's "and then" reference: https://www.youtube.com/watch?v=CkdyU_eUm1U

6: Null And Friends

Recursion, that infinite spiral of self referentiality. In this episode we break down the ideas behind recursion, and more importantly when and where you might want to use recursion.

7: Recursion

Oh category theory, bastion of strange and wonderful terminology, (some might say terrible and inaccessible). Love it or hate it, you're likely to run into some terms from category theory if you spend enough time in FP land. In this episode we'll tackle some of the terms that make up the 'ism family of terms, morphism, endomorphism, isomorphism, homomorphism, and catamorphism.

Denotational design talk: https://www.youtube.com/watch?v=bmKYiUOEo2A

8: Morphisms

Abstraction takes on a different meaning amongst functional programmers. This episode we dig into how parametric polymorphism is an essential tool in developing well behaved abstractions that transcend simply being a solution to your individual problem.

John Degoes polymorphism post
http://degoes.net/articles/insufficiently-polymorphic

When x, y, and z are great variable names
http://blog.ploeh.dk/2015/08/17/when-x-y-and-z-are-great-variable-names/

9: Polymorphism And Abstraction

Partial application and currying are a feature that is often mysterious to the uninitiated. Why do functional programmers care about such a seemingly useless thing? Partial application is an important part of the "FP toolkit" and we'll why and provide use cases for the importance of having partial application.

Simple made easy - https://www.infoq.com/presentations/Simple-Made-Easy
Scott Wlaschin https://fsharpforfunandprofit.com/fppatterns/ 
https://vimeo.com/113588389  - OO Patterns to FP Patterns talk

Lodash/fp - https://github.com/lodash/lodash/wiki/FP-Guide
Ramda - http://ramdajs.com/

10: Partial Application

We have launched our Patreon page, if you feel so inclined come support us at https://www.patreon.com/lambdacast

C# Maybe(and lots more)
https://github.com/louthy/language-ext

Immutable Collections API 
https://msdn.microsoft.com/en-us/library/mt452182(v=vs.111).aspx

Elm Language
http://elm-lang.org/

PureScript Language
http://www.purescript.org/

11: Aaron's C# Story

Into the icy maw of category theory starting with Monoids! In reality we find out it's not actually all that scary and there are some really fantastic things that we gain by understanding these basic categorical concepts.

We now have a twitter account! Follow us at https://twitter.com/lambdacast
We also now have a patron account if you're looking to support the show: https://www.patreon.com/lambdacast

Show Notes:

Haskell Diagrams library
http://projects.haskell.org/diagrams/doc/quickstart.html
https://vimeo.com/84104226

Chris Wilson pointed out that Haskell's Typeclassopedia has a nice chart of the relationship between Haskell's implementation of many categorical structures: https://wiki.haskell.org/wikiupload/d/df/Typeclassopedia-diagram.png

Lambda-Cast

Alfredo Herrera