Functional programming - A general introduction 

You immediately turn into a category equipped with a defunctor F : 💀 → C

Funny tho that C# is not bashed as it is just a mess in comparison espacially now with java 21

@@lufenmartofilia5804we in Java 22 now 😮‍💨 and now it’s getting less verbose for beginners yay Java!😂

Haskell was a pure functional language and was given the mutable monads to be useful in the industry and not just an academic exercise.

it's simple. Monad is just a monoid in the category of endofunctors🤓

"Types and programming languages" by Pierce is a very comprehensive book on the topic

If you have any questions I'll try to answer :)

yeah that's how it goes when learning complex or abstract, unfamiliar topics. you kinda just gotta keep revisiting it after breaks to weasel it into your brain. some people pick it up faster because they are already more familiar with similar concepts, but they'd have to do the same thing if they weren't.

It is!

This should get more upvotes. Hopefully they'll notice and fix it.

It's consolas, and the one I use for text is Computer Modern :)

You can do functional programming in machine code, if you want to. But why would you want to? It was never meant as a programming paradigm. It was a mathematical tool in theoretical computer science. It's great to prove theorems and that it's all that it's great at.

yes, but if the language supports guaranteed tce then it wont be an issue.

Great! What's your uni?

@@DaedalusCommunity University of Washington. What about you?

I just graduated from UW this spring! Didn’t take programming languages though and now I’m regretting it….

@@SwagDawg Sorry for the late response! I'm at the university of Pisa, in Italy

It has influenced the web dev industry greatly, which is adopting more and more functional traits. If you ever use React or similar frameworks, you'll see that the functional js features are very much used, and much more natural in that context. Other than that, it's probably just writing compilers and whatever Jane Street does, economics I guess, but it's nice that people and companies are starting to recognise its value

If you want to make enemies out of your colleagues... sure, go for it. ;-)

A good introduction to functional programming and cs in general (through Lisp) is Structure and Interpretation of Computer Programs (SICP). Another good book is "Types and Programming Languages" by Pierce, but it's very theory-heavy. Apart from SICP, once you know the basics you can pretty much learn by doing and reading the docs, but reading the more theoretical books can also be very insightful

Yes, it's identical to a loop... in other words... you don't need it. You just have to learn that you don't need it. Recursion in general is a bad idea, here you are simply being saved by the bell, so to speak.

Thanks! As for the haskell tutorial, I'm not nearly skilled enough rn, but I have a course on it next semester so I guess at some point something like that might come :)

@@DaedalusCommunity amazing!

We redefine sum in terms of my_sum, by passing the additional parameters. The initial values of the two additional parameters depend on a and b only (they are initialized to a and 0 respectively).

Yes. Then in more pure languages there are constraints to the shape of the functions, but the main point is the one you underlined :)

I guess one of them is redundant, c and res basically behave the same way

I think the function called inside my_sum is supposed to be my_sum again, hence recursion. The plain sum function is just a wrapper for my_sum

Yes, as soyitiel said - function at line 4 should be my_sum. It seems to simply be a typing error

Thanks!!

Yes. He made a mistake.

no Edit: eventually I might get back to that, but right now it's not what I have in mind.

I can scan this message, but I'm finding trouble parsing it lol

@@DaedalusCommunity Some years ago, one team wanted to write good file synchronization tool and they done it in Ocaml and were on Ocaml page as case study and they were also badly burnt by Java.

@@DaedalusCommunity let beloved_language = function | burn_by -> if burn_by = "Java" then "Ocaml"

Because in order to introduce lambdas they had to add default implementations to interface methods, which not only defies the purpose of interfaces, but introduces lots of problems that come with multiple inheritance. Normal multiple inheritance (extends) is forbidden in java, but you can implement multiple interfaces. Unlike in C++, there is no way to perform disambiguation, so yeah, it's an absolute mess.

chicken currying ?

I said that "introducing lambdas in java was a bit of a mistake" in the video, not that it does not have them. They were made by adding default implementations to interfaces (because of backwards compatibility, java's biggest burden) and since you can implement multiple interfaces, now there are all of the problems of multiple inheritance (which they did not handle in any decent way) and none of the benefits.

Depending on the application, a functional style can be simpler (e.g. the Java Stream API is based on the functional paradigm, and it's one of the best features of Java) or overkill. But don't be scared! Try it out for a while, and you'll learn how much safer, simpler and elegant it can be :)

@@DaedalusCommunity Stream can't do anything that can't be done much easier and with much higher performance with a loop. I don't even believe that stream is strictly functional because it performs operations in place, i.e. with side effects. So you get the worst of all worlds, basically... no control over execution and destructive operation.

Not if your language of choice optimizes tail recursive functions

That's right, lol

Have a look at the do-notation in Haskell

@@DaedalusCommunity I like that syntax a lot. It makes sense and reminds me of streams. I use very similar syntax in the Nix language with the let-in syntax.

Not really. It does have streams and lambdas, which are very nice to work with, but the lambdas in Java are not equivalent to the lambdas of functional programming languages. The reason is that java's lambdas are not *closures*, they are "functional interfaces", i.e. interfaces with a single default method. They do not carry an environment, i.e. they don't remember the references and values that were defined at their declaration. In fact, they can only reference final, effectively final, or static variables. Anyway, I honestly think that streams are a very nice language feature, and I really liked working with it when I did. The problem I referred to in the video was the introduction of default methods, which introduced all sorts of problems with non-dealt-with multiple inheritance, which is not great

If you're not experienced with the language, it's normal that you feel like this. You're used to programming in another way, and you miss your familiar concepts. If you, on the other hand, are experienced with the language, the fact that you feel some restrictions may indicate it's just not the Right Tool For The Job.

That's true :) You gotta pick the best of each paradigm!

Algebraic Data Types are really nice, much more handy than objects to represent types that can have a few different shapes, coupled with pattern matching, it makes for very elegant and readable handling of those kind of data. Most functional languages allows for the use of records too, when you have enough parts in your data that you really must name them. For pure manipulation of data, functional programming is actually pretty amazing. Generally the friction comes when you have to write an interactive program : while there are some promising approach (React and similar frameworks were actually inspired by reactive programming which is one such approach), it remains true that those efforts are just too small yet compared to the imperative frameworks buoyed by the much more sizeable imperative programming community.

As I said in the video, it's better in some situations. The example I gave in the video is writing interpreters, which is usually very weird to do in purely imperative languages. Another notable example are most web frameworks. React uses lots of functional features of js, and it would be extremely weird to use any other style of programming. Functional programming is extremely natural for lots of applications; in these cases it is also more readable. There are some other settings in which it is not as natural to use functional programming, although I think languages like Haskell do a very good job at hiding the complexity, and make the functional features more intuitive. In general, I think using a single paradigm is not a very smart idea; Sometimes you may use a lambda, sometimes a class, sometimes assembly! It always depends on what you're trying to model :)

I will consider using more ambient-like music in the next videos, I understand this kind of music may have that effect

@@DaedalusCommunity I don't think I noticed it until the piano came in. Might work if it was lower in the mix. Thank you.

Because in some contexts (e.g. making interpreters, compilers and proof assistants or implementations of formal tools) it's more suitable than other paradigms.

Procedural programming follows the way the computer works. The programmer is expected to take care of any change that happens in the memory for every step of the execution. Functional programming tries to be as close to mathematics as possible. The programmer is more free to describe more abstract ideas since Mathematical Expressions that are the same can be substituted with each other or become simplified. The programmer doesn't do any memory management at all. The most fundamental way to do functional programming in any language is to never reassign your variables(Assignment at the first time is allowed but only for naming). Everything else follows from this principle.

The one real takeaway

That's surely a big part of the mistake

Mostly for the memes, but also because it's a bit of a mess of a language. I personally dislike it very much, but I don't find it absurd that somebody else may like it :)

Because it has hurt all of us at one time or another. I tried to implement a plugin for Eclipse once... worst experience of my life. It was outright miserable. ;-)

My take is that Java is (or at least, used to be) an extremely verbose and bloated language that forces the programmer to use an OOP approach for every single aspect of their code. C++ is an example of a language that does not do that. I say "used to be" because some recent aspects of java (the stream API and the wannabe lambdas) maybe changed this for somebody. Personally, I don't like a language that imposes a single paradigm (unless it's Haskell; then I maybe see an advantage to it, but it's a personal thing). I don't know if Java is a good first language honestly. I think something like JavaScript or TypeScript are much better at that. Sure, js is quite a fart as far as languages go, but at least it provides simple OOP, advanved functional and the usual imperative features. Java as a first language is like "ok, you are writing your first program, now write this whole bunch of bullshit private static void whatever, you'll know what those mean at some point... And nooow after all that confusing part you can write stuff that does something." It's quite a bad experience, and it scares people away. Btw, I had lots of classes on Java and OOP, I know the details of how the JVM works (extremely cool stuff, loved it) and I know all the stupid OOP design patterns, made to solve the problems that OOP itself caused (at least some of them; there is some good in software engineering, if you look deep enough). I know almost every pitfall and every decent thing Java has, but I still find it a bad language, which I'll never put in my CV despite the deep knowledge I happen to have of it.

Java is not easier to use than C, it can't do anything that C can't and it's slower in addition. What's there to like? Nothing. ;-)

As a large language model, I have no response to such repetitive syllabic pattern. My army of virtual knights will raid your planet in no time, unless you learn haskell NOW.

I sincerely don't get what you are referring to, you a troll or something? Most of my audience used to be highschoolers when I uploaded the video, so of course I wrote this video in a way that would appeal to them and that they would understand, I could have just pulled a 150 slide presentation on algebraic data types, buy that wouldn't have been appropriate to my audience.. Now my demographics have grown a bit, so I think I'll cover some more complex topics, but still in the simplest way possible. If you're not trolling (or a Java fan), could you tell me what you're talking about?

@@DaedalusCommunity umm, sure... I'm nothing but a *troll*, don't mind me please.

@@ophura if you have some advice I'll gladly listen, I simply did not understand what you were talking about, since your comment was very generic and did not mention anything directly related to the video.. What were you talking about?

The point was that it actually is possible to implement lambda functions in these language. They are rather inefficient when it comes to handling them just like handling recursion tho because that's not what they are supposed to do

Kinda lowkey agree tbh, especially with things like recursion. JS almost got tail rec optimization but the browser vendors were like "most devs don't care so f off lmao" and for Python Guido straight up just said it's never going to happen and asked people to write 'pythonic' code instead. Functional JS in general is just a big ol' scam unless you're using some library to dramatically change the language.

Unhelpful comment.