i was numb through this, he really got me with that 1 + 0 = 0 + 1

This was the best VO talk I have ever seen. After watching and reseaching countless hours on the subject I can finllay get my head around it. Thank you!

Enjoyed the talk very much, especially the humor. I came here as a professional Scala developer after an interview where I failed to enumerate functional programming patterns I use. I leave kinda disappointed because I use most of these patterns daily anyway. I guess when I'm asked to enumerate functional programming patterns I use again, I'm just going to use the fancy names like continuations, monadic bind and functors.

The guy laughing like a hyena at 4:20... I mean, 4 20. Joke makes itself.

Thanks for sharing the video with us

That was epic :D. Thanks a lot!

Joker ??? 😂

I'm more interested into Haskell than F#. This talk is generic enough to be understood. Thank you, very well done.

There is a problem with the technique used at 57:40. The Order total is wrong when the code is refactored. Original: 2 * 19.98 + 1 * 1.99 + 3 * 3.99 = 53.92 Refactored: 6 * 25.96 = 155.76

Awesome! I never realized that such amount of usefulness was hidden inside ValueObjects until today...

The captions at 30:55 lmao

While I have quite a long way to go until I can properly re-program my brain to think more functionally, this talk really helped spark a couple light bulb moments. Some of the ideas I actually ran back to my company's OOP Enterprise code and implemented, funny enough. Great video, hopefully a couple more of these and I'll have my head wrapped around this crazy functional world :)

Awesome content! I come from java world and still find it very inspiring

Functional programming is all BS, summed up as f(BS)! None of these talks illustrate clearly how to use functional programming to solve a the types of problems developers need to solve. They always cherrypick some mathematical problem like Fibonacci sequences. They also emphasize brevity of the code without discussing metrics we really care about such as performance. It's all intellectual masturbation.

Probably the best talk I've watched so far on FP! Explained everything clearly!

Ivan, many thanks for taking efforts to upload this valuable video. Got a new direction of thinking.

I do not follow why some people are so thrilled by FP? At some point it looks simple but I see limitations mostly.

The only reason mathematicians got there first is because they didn't have computers way before we didn't.

Wow, great! I think that FP patterns combine nicely with DB in 6th normal forms, since you call functions with included another functions - > You get benefits of right definition what to call. And in some super fast DB where only value pairs are possible you could get super fast code. There is Convergence I think.

you talk about how object-oriented is bad in the example where methods that take a string, expecting an e-mail address, could pass in some other string that's not an e-mail address such as a last name, to present the benefit of value-objects. but then you talk about how interfaces aren't needed in F# because you can functions compatible based on structure. It's a little bit misleading because in object-oriented programming, interfaces are the way you give data stronger type-safe guarantees. The interface from OOP which you seem to down-play *is* the primary mechanism to provide a type .

One of the best intros do FP, hands down. Every concept is explained in a clear, pragmatic way and on top of that Scott has a great sense of humor!

This was a very good presentation. But the more i watch/learn about FP the more holes i discover. For very small benefits we add so many not necessary things, complexity, dependencies, ugliness of code, non-uniformity, potential for errors ...

Next time take some cough medicine before you give a talk 😐

That's a very first CS semester talk. And give this man some water!

this is what happens when you invite a standup comedian to a technical conference

I came for the FP, I stayed for the LOLs.

Is there no straightforward way to define NonZeroInteger type?

Best talk on FP I've seen. Thank you.

Alright I'm sort of confused. At 23:19 he talks about how he could rewrite the interface in F# using one function... If the interface is already only one method, and that method only accepts int and returns int. Could he not have just done the same thing in the original language by just ... scrapping the interface?

what's with that hohohahaha? 🤔

brilliant

Still a great presentation even today. Thanks for posting.

Strait to the point - I loved it! :)

The equivalent of Objects in Functional programming are actually not functions, it's actors.

That guy man, I guess he is a best friend of the speaker.

Also www.smashcompany.com/technology/object-oriented-programming-is-an-expensive-disaster-which-must-end

Thank you for this great talk!

Does List.fold loop or is it a recursive higher order function? He says loop in the video but I am guessing that is just a hiccup and he means recursion but I don't know f#. From my understanding a big part of functional programming is treat data as immutable, so no loops. Is that right?

Actual talk begins at 6:45

You can't really have something like NonIntegerZero in most languages. This is sort of the limit of even the most powerful static type systems. It is the domain of dependent typing but then you have to give up Turing-completeness...

basically many presenters which i have seen so far started introduction into FP same way as the last statement. "Monad is just a monoid....." together with bunch of lines with FP stuff while repeating same words over and over. Monoids, monads, functors, endomorphisms without explaining single word. This guy made this stuff much more clearer. Very good presentation.

I made it to ivory tower before audience laughter became to annoying

Functional patterns allow you to accumulate a lot of calories in your body.

who is the guy with wide laughter? since he get every point, must be another FP expert

Excellent talk

1) 43:05 I didn't get the error handling part - he showed the code before and after error handling, it was the same, ok great soooo - where was the error handling? where did all the different error messages go? they were different for each error so surely you had to put them somewhere... highly misleading (he suggested 200% extra lines just for error handling, 0 extra lines for error handling in F# - that's what i'm challenging: the code did go into the monads sooo ... it's not like it disappeared ;) 2) 42:26 he got the promises wrong - the promises ACTUALLY SOLVE the pyramid of doom the exact same way bind does :-D he presented it as if they just rewrote it in different words.

In minute 16:00 he talks about a NonZeroInteger that fails at COMPILING TIME, how can we do this in F#? I cannot find anyway to do that.

Top floor is for Martin-Löf, Idris, Agda, Coq and the like.

Is it just me, or does anyone else think exceptions are kind of nice. Why do the extra work, everyone knows what divide by zero exception means. Handling exceptions with try catch and doing some custom logic is hardly a new concept.

I took a lot from this but def started to lose me around 42:00 (although that does look a lot like error handling in node)