sleep

Web Development

lambdacast

λ · 🔊 ≟ The Greatest Hits

programing

Mysterious Product's  Deep Sleep - Counting Sheep single, a magical sleep inducing session from the album, "Deep Sleep". THIS TRACK INCLUDES BILATERAL, BRAINWAVE BINAURAL BEATS IN THE THETA RANGE.*

Recommended Usage: Listen as needed. Results may vary. You may listen with or without headphones. Lay down in a quite, relaxing place without distraction for the duration of the audio session.

*Important Note
People with the following conditions, should consult their doctor before listening to the Brainwave Entrainment sounds.
When driving or operating heavy machinery
If you suffer from any type of epileptic seizures
If you suffer from psychological or psychiatric disorders
If you have a pacemaker
If you have high blood pressure
If you are under 18 years old

*This track is in Medium Quality. You may purchase the High Quality Track for Download. For a limited time you can download this track by signing up to our email Newsletter!

Deep Sleep's "Counting Sheep" Brainwave Binaural Beats

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 with.

Tell us what you think at contact@lambdacast.com

Transcription provided by Eric Inman
https://drive.google.com/file/d/0B3raKkneFJOXSU1rWEstSUwxTk0/view?usp=sharing

1: Overview Of Functional Programming

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

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

12: Monoids

Rodney Urquhart grew up in a North Philly neighborhood ridden with gang violence and effects of the crack epidemic. After seeing people around him get involved with gangs and crime, he realized that staying in high school would result in getting arrested or shot. 

At 16, Rodney dropped out of high school and moved in with his grand mother. Being a high school dropout and having no college degree, Rodney had his fair share of companies casting doubt on his ability. But his willingness to learn and work well with others was what got him to create an impressive company portfolio including Comcast, Microsoft’s Yammer, and ThoughtWorks. He didn’t just want to survive, he wanted to thrive. 

Rodney currently heads the test infrastructure team at Slack. He is also part of a program called /dev/color, a non-profit organization that aims to maximize the impact of Black software engineers in the tech space.

#28: Rodney Urquhart - How a 16-year-old High School Dropout became a Software Engineer at Slack

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/

13: ADTs

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 Wooley
David Keathley
Andre Carvalho

Show Notes:

Coconut programming language: http://coconut-lang.org/

Hack nights instead of presentations: http://tech.noredink.com/post/142283641812/designing-meetups-to-build-better-communities

class Functor f => Applicative f where
  pure :: Applicative f => a -> f a
  ap :: Applicative f => f (a -> b) -> f a -> f b

Example of applicative usage:

pure (+) <*> Just 3 <*> Just 2 -- this results in Just 5
(+) <$> Just 3 <*> Just 2 -- this is the same as above
liftA2 (+) (Just 3) (Just 2) -- alternate form using lift instead of infix operators

17: Applicative Functors

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:
Pluton
Tim Buckley
Huge shout out to Marcus Nielsen

Show Notes:
bind :: m a -> (a -> m b) -> m b

Example of do syntax vs using bind aka >>=:
main = do
foo <- doMonadyThing
foo2 <- doOtherMonadyThing foo
pure (whatever foo foo2)

main = doMonadyThing
>>= (\foo -> doOtherMonadyThing foo 
>>= (\foo2 -> pure (whatever foo foo2))
)

Extracting a value from a Maybe

extract :: Just Int -> Int
extract foo = case foo of
Just num -> num
Nothing -> 0

Railroad oriented programming talk by Scott Wlaschin
fsharpforfunandprofit.com/rop/

FP Chat Slack Community: https://fpchat-invite.herokuapp.com

18: Monads

LambdaCast is a podcast about functional programming for working developers. Our focus is to describe concepts using clear everyday language without watering anything down. If you've ever been curious about FP but were turned off by the jargon or unfamiliar concepts, this is the place to be.

Thoughts, comments, critique? Send them to contact@lambdacast.com

Music is "Lively Lumpsucker" by Kevin MacLeod (incompetech.com)
Licensed under Creative Commons: By Attribution 3.0 License

Icon is a modification of "Communicator" by Juan Pablo Bravo (https://thenounproject.com/term/communicator/47500/)
Licensed under Creative Commons: By Attribution 3.0 License