Like me teaching.

And somehow made it include biology and history

No new concepts were introduced.

@@vendicarkahn4860 There is nothing new under the Sun.

The answer is actually surprisingly simple. - Ceave Gaming

hahahahaha

who cares functional programming is useless to know anyway

He said computer scientist, not programmer.

@@AllUpOns it's true! Functional programming is rather inneficient generally if you want to get things done, but are useful for proving things, I guess

@@mrpedrobraga Not only for proving things really IMO. It's very useful when you need extra control of the program state, when there's a lot of inputs and outputs. That way having pure functions, higher-order functions and controlled storage makes it much easier to see what's going on in your environment. You can take a snapshot of your state or even reverse it, you can control state flow in general. Not saying that it's impossible with an imperative way, but the concept itself I think means a lot and makes a great change if used properly, even if it's completely abstract and has no connection whatsoever with what's going on in the program really. However, you'll likely will sacrifice performance, and if performance meant by "efficiency" I think that's true it's rather inefficient because computers are really Turing machines, and state and sequences means a lot. So I guess any functional language backend built with a lot of abstractions which give some performance penalty -- as with the majority of abstract structures. I don't have CS degree however, maybe I'm wrong but from my experience they were a bit slower usually. But if you need to take a control over something complex, lambdas are great too in practical programming. And sometimes it's just simpler to express something in lambda/functional way! At least any SE student should try to. At least for me, it changed mindset quite much. That's why it's so popular nowadays I think and should be deeply covered on SE programs instead of some "Best Practices" for another getter/setter in Java or C#.

Haha I was lucky to be his student learning Haskell in his course last year, his teaching was the best!

Thank you for sharing this. I'm currently reading his Haskell book as well and didn't realize it was him in this video.

is the book as verbose and confusing as the video? "Love" his choice of function names same as Boolean values. No operation precedence "helped" as well. Watched 5 times.

​@@ltpetrenko Remember that this introduction to functional programming is taking place in Untyped Lambda Calculus; the idea is that there is no such thing as a Boolean value until you encode it somehow, which is what he's showing here. In other words, the functions and the types aren't "sharing" a name, the functions themselves define the types, so they literally *are* the same thing, in the same way that your name and you are the same thing. The precedence in functional programming can definitely be pretty confusing at first, but it's actually really simple. Literally just start reading from left to right, taking however many arguments you need. It looks weird, but literally just apply the function: TRUE means pick the first of two things, whatever they are, so if you have TRUE FALSE TRUE, obviously the first thing is the function, and FALSE is the first of the two arguments, so that's the result of the function. Believe it or not, this idea gets even simpler. The fact that you can represent any computation by a sequence of partial function applications in which each component function takes only one argument is related to something called the Curry-Howard Isomorphism, and Haskell programmers use this pretty frequently in what's called point-free notation, if I remember correctly. The point is that the sheer simplicity of these ideas can actually be really counter-intuitive, so I definitely don't blame you for feeling frustrated. To be honest, I genuinely loved the book, but I paired it with a bunch of additional resources, like "Real World Haskell", "the Haskell Road to Logic, Maths and Programming", and Bartosz Milewski's awesome Haskell tutorials at School of Haskell. It can feel like every statement is either clearly obvious and useless or super abstract and useless at first, but if you can hang in there until it clicks, I think it's 100% worth it.

@@jflopezfernandez thank you for such a thorough reply.

I think it was Michaelangelo who demonstrated he could draw a perfect circle.

Giotto, actually.

more laughs from him would be cool

yea, that's freaky. its incorrect that they are so correct. im mad about this.

I really thought I was the only one who had notice... felling better now :)

so basically it is something like this ? f(z,y,z) = x+y+z would be λx.{λy.[λz. x+y+z]} or λz. { λy.[ (λx.x) + y ] + z }

@@xr_xharprazoraxtra5428 a typo: f(x, y, z) instead of f(z,y,z)

@@ExaltedHermit oops XD

You mean in the context of lambda calculus only? Because logically, functions can take more than one argument.

@@GkTheodore Nope, they can't. You only think so. f(x,y) is not really a function with two parameters. It is a tuple, hence only one parameter.

nerd

I've been obsessed with the correlation of recursive computation, evolutionary biology, DNA, and Godel's incompleteness theorem. Any ideas on this from your experience in bioinformatics?

Object Oriented Programming is way more related to biology than functional programming

@@phillipanselmo8540 You have no idea what you're talking about.

😂😂😂😂😂😂😂

Thank you! I thought we take TRUE, then pass its output to FALSE, then pass its output to TRUE again, and have several undefined inputs! But now i get it. Thank you again. :)

Just wanted to say that you did great with making the translation to more modern syntax. However, TRUE(FALSE, TRUE) is not an entirely accurate translation. You should look at it as (TRUE(FALSE))(TRUE). The first application of TRUE(FALSE) returns a new function which you later apply to TRUE. If you are interested in these kind of things you should look up "currying".

@@christophescholliers5141 true was defined to take two inputs, was it not? how can it suddenly take just one function?

ah, never mind, some gentleman actually already answered that exact question elsewhere in the comments :D

Christophe Scholliers hahahahaha I just came from this Chanel’s video on currying after it told me to come here

soon

spj and then he will just refer back to this video...

Yes, please

where he gives an example of him discussing Lambda Recursion

please, Yes

I know first and last name, but what computer science terminology is "brooks"?

en.wikipedia.org/wiki/BrookGPU en.wikipedia.org/wiki/Haskell_(programming_language) en.wikipedia.org/wiki/Curry_(programming_language)

And don't forget currying! ;-)

That's one of the most bass-ackwards way of looking at things I think I've ever read. Don't you think that a MUCH better statement would be, "What an achievement, to have three computer science terms derived from your first, middle and last name"?

Thats not true though. BrookGPU is completely unrelated to Haskell Brooks Curry.

Sounds like intellectual masturbation. Need a TRUE? Use 1. Construction finished.

​@@frankfahrenheit9537 That's fine if you are the one writing all the logic, what Lambda calculus allows you to do is pass around actual logic like you do with data. That's why languages like C# can have a Method called .ForEach(Action Lambda) where Action is a Lambda expression that doesn't return anything but its logical definition is provided by the programmer using the method OR in a more advanced idea since any logical idea can be represented in a lambda expression you can have a program that allows an end user to check boxes and select drop downs that collectively feed into generating logic that is converted into a lambda express and passed into the existing code base to then be executed like it was originally written into the program. pretty crazy and fun stuff to play with. To make all that work the programing framework needs to understand the FULL language of logical representation. Abstract Syntax Trees are how that happens Simple example NOT (A OR FALSE) translates to Unary Expression - Lambda Expression Takes 2 parameters The Operator [NOT], and a Value [The result of (A OR FALSE)] , it returns one value L_Operator Expression - Lambda Expression Actually does the NOT logic L_Group Expression [( )] - Lambda Expression Takes multiple parameters) returns one value L_Binary Expression [A OR B] - Lambda Expression takes 3 parameters, Left [A], Right [FALSE], Operator [OR] it returns one value L_ Value Expression [A] - Lambda Expression takes 1 parameter [Variable name], returns the in memory value of that variable L_ Constant Expression [B] - Lambda Expression holds a constant value in this case FALSE L_ Operator Expression [OR] - Lambda Expression defines how the Left and Right parameters are combined It can get pretty nuts looking into an abstract syntax tree for even the most basic algorithms but understanding that the ONLY thing the computer understands is Expressions all we do is teach it to tell the difference between common expressions by abstracting away the differences e.g. Binary Expression (can be ANYTHING that takes two inputs and gives one output, +, -, /, *, OR, AND, XOR, NOR, etc) pretty powerful stuff in a REALLY condensed code base if you actually look at the logic for how abstract syntax trees work (just a logic wood chipper that keeps breaking it down into its most basic parts and then executing or reconstructing them as needed)

@@frankfahrenheit9537 This is the difference between programming and computer science. Yeah, if you're making a game, just use 1. If you want to better understand the logical structures that can go into programming languages, then abstractions are necessary.

The point that's being missed is that it's a universal language the way NANDs are universal operators, By combining nothing but NAND gates or the three lambda constructs, you can compute anything.

But does it still work?

I didn't get that at all x.x

beautiful

Thanks for the info :)

mem reflect And here we see the trivial mapping from LISP’s s-expressions (and also RPN) to lambda calculus - and back :)

I think this all stems from the inverse relationship between comprehensibility and availability of grant money.

I don't know why CS curriculums still treat it as alternative. You'd think both theoretically and practically, these things should be front and center.

it’s a shame anyone would ever return to java

For the record: In most imperative programming languages, a lambda just means a function that you can pass as if it were any other data type (like a string).

Same here. I really appreciate the video, but it is quite abstract. I didn’t have an ‘Aha Erlebnis’. Also, i cannot read the text on the paper sheets. Why not present it full screen. It’s nice to see your face, but it doesn’t help me understanding it better.

Unfortunately this channel is ruined by the bad camerawork.

... and bad choice of clothing for sitting in front of a camera.

golly you sure have a low bar for what constitutes "ruined"

gabbergandalf667 some people are never happy

Lol first it was the audio now it's one of the cameras.

The point was to explain what the lambda operator does in a method that isn't entirely abstract.

Well, of course! What do you think CPU architecture ultimately boils down to? It's of no coincidence.

I've been watching Half-Life videos recently and got "Lambda Calculus" recommended to me.

4:42

It all translates to final state automata. which uses a regular language, which means you can express every line of code with that logic. Maybe useful if building minimal models which means your code running the best way possible?

@@soundcore183 Applied lambda calculus is basically functional programing. The main feature of which is that there are no side effects from using any function. You generally have to go out of your way in functional languages to get side effects (i.e. actual data being written/modified). This can become extremely useful in situations like multi-threading or server connections. It also offers a lot more consistency to the code, since the outputs don't depend on anything other than the actual inputs given to a function.

If I'm not mistaken, it also bridge mathematics and computers. In the beggining computer were made to do maths calculation. The mathematical notion behind calculation is functions, which is formalised in set theory. Those functions themselves formalise equation in physics I guess. The thing is that set theory doesn't mean anything in terms of digital electronic circuits. That is why Church wanted to formalise mathematical functions in a way that means anything for electronics. He came up with Lambda calculus. Then the Churh-Turing hypothesis say that lambda calculus and turing machine are equivalent, or something like that. Then the Turing machine concept, implemented with von Neumann architecture were used to make working general purpose computers.

@@soundcore183 lambda calculus is more powerful than regular expressions. Lambda calculus is equivalent to a turing machine and hence is more expressive.

aiklarung yep

Does it? I didn't get anything out of it. I understand the point with having anonymous functions (which I implemented in my language's compiler), and I know they are called "lambdas" :) But that's it.

For a brief explanation: Y=λf.(λx.f (x x)) (λx.f (x x)) if we apply Y to some function g we get: Y g =(λf.(λx.f (x x)) (λx.f (x x))) g = (λx.g (x x)) (λx.g (x x)) (this process is called beta-reduction, btw) Applying the first λx to the second λx yields: g ((λx.g (x x)) (λx.g (x x))) now, the parentheses contain identically Y g (from the 4th line), so we have: Y g = g (Y g) The fact that that's recursive should be self-evident.

Thanks, but that doesn't help.

To elaborate a little, in the line beginning "Y g", I'm simply substituting g for f. In the line beginning "g ((", I'm substituting the second "(λx.g (x x))" for x in the first "(λx.g (x x))". After you do both of those things, you'll notice that the thing inside the parentheses after the g on that line is the same as the result of substituting g for f, hence Y g = g (Y g). This is recursive because you can keep substituting g (Y g) for Y g, getting g (g (g ...(Y g)...)). To be clear this is an infinite recursion, not a terminating one. Sorry if that didn't clarify anything.

That's much better, thank you!

great idea. i would love to see an explanation of that thing

pause buttons are real.

Did you know, pause buttons are a thing?

XD

Buncha smart asses think you want to just stare at the equation in silence and ponder it for a bit rather than hear the related dialog concurrently, apparently...

Just to clarify, there wasn't any code in this video

With your example there really isn't one. But lambda calculus is all about functions. It allows you to apply functions to other functions nicely. Look at the example with NOT in the video. You couldn't really do that (efficiently) with the conventional f(x) = y

not(b) = b(false, true)

The second is syntactic sugar for the first. ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-001-structure-and-interpretation-of-computer-programs-spring-2005/video-lectures/

f(x)=x+1 f(5) is classical Mathematics: x is a real number and you can apply algebra and you can have numbers like 1.2435278567... heck, you can even have numbers with infinite never-repeating digits that would take infinite amounts of information to describe and it still holds. (λx. x+1) 5 is lambda calculus, which is really a programming language and not a math system, you can't really do algebra on it and fundamentally it doesn't even really have numbers: +, 1 and 5 are actually functions in this example - ex: 5 is a function that takes its input and turns it into a function that's the same but applied 5 times. Lambda Calculus can't really have infinitely random numbers, with infinite digits and requiring infinite amount of information to express. Lambda Calculus ONLY has functions. Logically, your functions take a function as an input and return a function as a result (since there are no other manipulatable objects). The insight is that even just having functions that take a function and turns it into a new function is actually so powerful as a mechanism that you don't need anything else.

+boptillyouflop You can encode algebra in lambda calculus.

Designing programming languages is definitely not simple haha

Is correct. In Haskell this syntax is used. For lambda is \ normally used

yet there's no 3

Whatth lithp?

There's probably a lambda expression to explain it known as recursive releases.

The lambda calculus has a big advantage for modern computing. It can more easily take advantage of multicore machines as it does not rely on state, and proper implementations of it in languages like haskell make it very easy to work with. Worth at least learning Haskell and building a few things with IMO.

Pretty sure they actually do have to and that it was just an example. One for example has to be encoded.

They do have to be encoded, but since this was an example, it had to be simple, and was therefore dumbed down to a level that needed no prior knowledge to understand. The number 1 needs to be encoded, as well, BTW.

They do, and by missing explaining that, the lecturer threw the baby out with the water

The ligma calculus is closer to the updog calculus.

What’s updog calculus

@@eldaneuron4183 You'd need to know the sugon identity to understand that.

What's Ligma?

Benefit

5. Receive likes

It becomes polka dots

My understanding is that state is something that is mutable. The 1 is a constant, and thus is allowed, merely being a part of the definition. Just like the +.

it means no information can be stored or altered in the function, so you get the same value for every input

State is something that can change and is not inherently constant. The function would be having state if the value that is added to the input would increase with each call of the function, for example. So as long as the only things that the function consists of are unchanging constant values and the input arguments, it does not have state. I hope that makes sense somehow.

Think of a function as a huge look up table of values. For example, for the function x mapsto x + 1, you regard it as the table "1 -> 2 ; 2 -> 3; 3 -> 4; ..." etc. Of course, this is impossible to do in real life, but who cares about that ? Conceptually, it's true, and that's what's interesting here. You can see from this view how the function doesn't have a state : it's not "thinking", it's just looking at the input and returning the right value, and there's no state in that.

Here, take this: λ

You better forget this video ASAP

By the way, your videos are awesome

Back in the days, that's what a printer printed on

@@d-rex7043 i actually like it, weirdly

More interesting is the question whether DNA is recursive.

David Wührer Recursive on terms of what ?

Furkan Kılıçaslan​​​ From the Devil's Data Processing Dictionary: recursion: n. _see: recursion_ Another way to put it is to ask if it can do loops. Again from the Devil's DP Dictionary: endless loop: _see: loop, endless_ loop, endless: _see: endless loop_

David Wührer I know what recursive is and there are some repeating sequences in DNA but i am not sure if DNA can be called recursive

Furkan Kılıçaslan Neither am I, which is why I think it is an interesting question. We know it is code, and it involves programs for proteins as well as code about how to process them, and even about turning parts of the code on and off, as well as error correction and redundancy. But do the processors process the programs purely sequentially, or can the code refer them to other parts of the code? More topically: Does DNA encode instructions on how to decode instructions in the DNA or derived from instructions in the DNA? In some sense it has to, because it replicates itself by following the instructions it replicates via processors built from these instructions. But is the encoding itself recursive? Does it maybe have an equivalent of the Y-combinator? Or is the self-replication the only recursive aspect of it (which is more a phenotypical property, depending on how you look at it). The double helix structure is more about the re-assembly of the code after use, as far as I understand, and the similarity of it to function definitions more or less co-incidental. How deeply the code can be mapped to purely mathematical concepts however, or if it can at all, is the interesting question hinted at here.

Interesting

I had to watch it like 3 times and follow along in Haskell before I got it lol.

yes