Folgen
-
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 Sooter
Jamie Rolfs
Christian Hamburger
Daniel Svensson
Di Wen
Iulian Bojinca
Jonathan Fishbein
Nathan Sculli
Nels Wadycki
Paul Naranja
Peter Tillemans
Thomas Varney
Tyler Harper
weila wei
Dawn (שחר)
Show Notes:
CPPCast: http://cppcast.com/
John Soo - Sharing in Haskell
https://wiki.haskell.org/Sharing
https://stackoverflow.com/questions/1105765/generating-fibonacci-numbers-in-haskell
Alejandro’s link to Phantom Types article: https://www.objc.io/blog/2014/12/29/functional-snippet-13-phantom-types/
FP Chat Slack Community: https://fpchat-invite.herokuapp.com
Intro/Outro music is "Lively Lumpsucker" by Kevin MacLeod (incompetech.com)
Licensed under Creative Commons: By Attribution 3.0 License -
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 using them can improve the structure of your applications.
Episode 21 patrons:
Scott Smith
Joel McCracken
Hakon Rossebo
Seth Utecht
Christophe Pereira da Conceicao
E. Mulder
Show Notes:
Add a type parameter video: https://www.youtube.com/watch?v=BHjIl81HgfE
Matt Parson's follow-up post: http://www.parsonsmatt.org/2017/04/08/maybe_use_a_type_parameter.html
Stephen’s Twitter: https://twitter.com/S11001001
Type Parameter example in Scala: https://typelevel.org/blog/2015/09/21/change-values.html
FP Chat Slack Community: https://fpchat-invite.herokuapp.com -
Fehlende Folgen?
-
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 laziness.
Episode 20 patrons:
Marcus Nielsen
Steven Loe
Ted Yavuzkurt
Michael Meyers
Szymon Beczkowski
Parl Naranja
Paul Brabban
Jason Sooter
Show Notes:
Memoization: https://codeburst.io/functional-memoization-in-javascript-adec62508bd0
Using IEnumerable in C# to generate an infinite sequence: https://brianreiter.org/2011/01/14/ienumerable-is-lazy-and-thats-cool/
FP Chat Slack Community: https://fpchat-invite.herokuapp.com -
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 Sculli
Lee Beck
David Joyner
Nihohit
Charles Winebrinner
FP Chat Slack Community: https://fpchat-invite.herokuapp.com -
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.Episode 18 patrons:PlutonTim BuckleyHuge shout out to Marcus NielsenShow Notes:bind :: m a -> (a -> m b) -> m bExample of do syntax vs using bind aka >>=:main = dofoo = (\foo -> doOtherMonadyThing foo >>= (\foo2 -> pure (whatever foo foo2)))Extracting a value from a Maybeextract :: Just Int -> Intextract foo = case foo ofJust num -> numNothing -> 0Railroad oriented programming talk by Scott Wlaschinfsharpforfunandprofit.com/rop/FP Chat Slack Community: https://fpchat-invite.herokuapp.com
-
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 problems.Episode 17 patrons:Chad WooleyDavid KeathleyAndre CarvalhoShow Notes:Coconut programming language: http://coconut-lang.org/Hack nights instead of presentations: http://tech.noredink.com/post/142283641812/designing-meetups-to-build-better-communitiesclass Functor f => Applicative f where pure :: Applicative f => a -> f a ap :: Applicative f => f (a -> b) -> f a -> f bExample of applicative usage:pure (+) Just 3 Just 2 -- this results in Just 5(+) Just 3 Just 2 -- this is the same as aboveliftA2 (+) (Just 3) (Just 2) -- alternate form using lift instead of infix operators
-
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:
Chris Krycho
Tyler Harper
George Webster
Show Notes:
Functor
map :: (a -> b) -> f a -> f b
Bifunctor
bimap :: (a -> b) -> (c -> d) -> f a c -> f b d
Profunctor
dimap :: (a -> b) -> (c -> d) -> f b c -> f a d
Phil Freeman's talk on Profunctors: https://www.youtube.com/watch?v=OJtGECfksds -
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 Lopes
Gabe Johnson
Randy Shepherd
Noel Waghorn
Correction: I incorrectly stated that one of the Recurse Center Social rules was “No Feigned Ignorance” it is actually “No Feigned Surprise”
Show Notes:
Cloud Haskell - http://haskell-distributed.github.io/tutorials/1ch.html
Recurse Center Social Rules - https://www.recurse.com/manual
Lambdaconf COC - http://fantasyland.institute/initiatives/COC.html
Moonconf COC - http://maitria.com/coc
Haskellbook - haskellbook.com
NY Haskell speaker guide - https://docs.google.com/document/d/1065iwf918SDotEPc0q9TWP_F1haVyeK90MSaBg3IOn8/edit
Spa day instead of pub meetup - https://twitter.com/sehurlburt/status/875848925529243648
Steven Syrek - https://twitter.com/sjsyrek -
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
Andrew Newman
Derek Morr
Olov Johansson
Show Notes:
Philip Wadler Talk: https://www.infoq.com/presentations/category-theory-propositions-principle
Denotational Design
Scott Wlaschin Poker Implementation
https://exit.sc/?url=https%3A%2F%2Ffsharpforfunandprofit.com%2Fddd%2F
Conal Elliot presentation on Denotational Design
https://www.youtube.com/watch?v=bmKYiUOEo2A
Our recomendation for a DDD book
https://www.amazon.com/Patterns-Principles-Practices-Domain-Driven-Design/dp/1118714709 -
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.com
Support us on Patreon at http://www.patreon.com/lambdacast
Follow us on Twitter: http://twitter.com/lambdacast
Show Notes:
Denotational Design with the example of a Poker game
https://fsharpforfunandprofit.com/ddd/ -
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 -
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/ -
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/ -
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/ -
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 -
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.
-
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 -
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.
-
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!
-
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]
Show Notes:
https://www.destroyallsoftware.com/talks/boundaries
http://blog.ploeh.dk/2015/08/17/when-x-y-and-z-are-great-variable-names/ - Mehr anzeigen
