This time we discuss the way data tends to be structured in functional languages and some of the similarities with databases and REST.Episode 22 patrons:Jason SooterJamie RolfsChristian HamburgerDaniel SvenssonDi WenIulian BojincaJonat

21: Type Parameters

Aug 10th, 2018 1h 14m

You may have seen generics in C#, Java, or Swift but there are a lot of very useful patterns using generics that rarely get used in an OO context. In this episode, we explore Type Parameters (aka generics) from a functional perspective and how

20: Laziness

Jun 18th, 2018 57m 19s

Lazy evaluation is not normally something you hear programmers discussing but there is a lot of power available if you know how to use it. This episode we'll examine the differences between lazy and strict evaluation and look at use cases for l

19: Starting A Project Functionally

Feb 16th, 2018 1h

Logan walks us through what his experience has been starting a JavaScript project in a functional style and using the best FP tools he can get in the JavaScript ecosystem.Episode 19 patrons:Nathan SculliLee BeckDavid JoynerNihohitCharles

18: Monads

Nov 17th, 2017 1h 24m

Monads, the promised land of functional programming. Or at least with all the hype they'd better be! Come join the cast as we demystify this overhyped structure that has become an indispensable part of many functional programmer's toolkits.Ep

17: Applicative Functors

Aug 26th, 2017 58m 44s

Building on the power of functors we examine a few scenarios where a normal Functor is problematic. Fortunately, there is a closely related structure known as an Applicative Functor that can provide the capabilities to solve a broader range of

16: Functors

Jul 23rd, 2017 1h 6m

Going deeper down the category theory rabbit hole, we explore one of the most common and useful abstractions in the functional programming world. You're likely already familiar with Functors but just didn't know it yet.Episode 16 patrons:Chr

15: The FP Community

Jul 6th, 2017 1h 16m

Join us as we discuss the FP community. FP has a reputation as harsh and impenetrable but is that really the case? What can you do to make FP a more inviting place?Episode 15 patrons:Chris LopesGabe JohnsonRandy ShepherdNoel WaghornCor

14: Dynamic and Static Languages

Apr 23rd, 2017 1h 17m

The kind of type system a functional language uses has a large impact on the way you use that language. In this episode we discuss the tradeoffs involved in using a static or dynamic language.Our patreon sponsors this month:Javier Troconis

13: ADTs

Mar 3rd, 2017 1h 10m

Algebraic Data Types (ADTs) are one of the most distinguishing features of statically typed functional languages. Come learn why they exist, how you can use them, and how they change your design. Join the FP community at http://fpchat.comSup

12: Monoids

Feb 13th, 2017 1h 5m

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

11: Aaron's C# Story

Jan 27th, 2017 1h 1m

We have launched our Patreon page, if you feel so inclined come support us at https://www.patreon.com/lambdacastC# Maybe(and lots more)https://github.com/louthy/language-extImmutable Collections API https://msdn.microsoft.com/en-us/librar

10: Partial Application

Jan 6th, 2017 1h 9m

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

9: Polymorphism And Abstraction

Dec 21st, 2016 1h 23m

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

8: Morphisms

Nov 24th, 2016 43m 9s

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'

7: Recursion

Oct 26th, 2016 43m 45s

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.

6: Null And Friends

Oct 10th, 2016 49m 19s

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

5: Immutability

Sep 26th, 2016 59m 38s

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.

4: Higher-Order Functions

Sep 4th, 2016 48m 39s

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!

3: Why FP?

Aug 14th, 2016 1h 31m

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 [email protected] Notes:https://www.destroyallsoftware.com/talks/boundarieshttp:

2: Overview of Functional Programming part 2

Jul 31st, 2016 1h 40m

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 [email protected] Notes:https://www.infoq.com/presentations/Simple-Made-Easyht

1: Overview Of Functional Programming

Jul 11th, 2016 1h 13m

In this first episode we discuss the big picture ideas that make functional programming distinct from other styles of programming. No experience required! If you're interested in learning what the fuss is about, this is the episode to start wi

Rate