HaskLUL 

Now extend to explain the difference between functors and applicatives lol

Exactly! Perfect description of how xmonad twm works.

And how that differs it from a monoid? Or a functor?

this is the best monad explanation every wtf

A monoid is a thing that combines two things into one, together with a thing that makes a thing out of nothing, subject to some laws. That is why a monad in C is a monoid in the endofunctor category C: you have a way to combine a double-wrapping into a single-wrapping, together with a way to wrap something, subject to some laws.

The 8th circle(fraud) is for bad programmers apparently, according to GPT.

I'm too scared to answer

That depends on how much time he'll have to spend on monads. The usual line of learning goes semi-linear until you get there. Then you can take a long time to understand monads to the level where you can write code which uses them. It can be a few days, it can be months, you can never learn it....

NO

God I hope not. Haskell has so many real world problems. Most people here probably know haskell usually becomes a hassle. Its one of the main reasons why rust took over. I'm a haskeller and I only use haskell for parsing and compiling and using the library megaparsec and other parsing libraries to convert languages to another language. Haskell is like a perl with more stupid disguised as pompous elitism using borrowed vocabulary and incorrect metaphors from advanced math. I took level 2 imaginary math and it made my journey even worse with Haskell back in 2012 because I expected monad to be like the mathematical definition, but nope. They changed the definition of monad for Haskell. They did that through all of haskell with the phony use of mathematical terms.

@@complexity5545 they didnt change the definition, they just broadened it for programming use case no?? Also, yes building a JSON parser in Haskell is my inly real world use of Haskell lol.

Backus was one of the og gigachads

There is a Fortran '54

@@ccgamedes33 That's what I use.

He probably died from C++ 03, tried to hang in there for like four years and then just couldn’t anymore

John Backus was a legend, and more programmers today should learn about what these pioneers accomplished with such incredibly limited hardware. He was a Turing award winner, and the paper mentioned was from his acceptance speech.

Bimbo programming is a thing?

The opposite is also true, look at C++.

a tall ivory tower played

i'm gonna assume "tall white fountain" is someone coming

this should be a metal song

@@feschber It's just Vladimir Nabokov if he was an enlightened Haskell enthusiast instead of a cringe 20th-century author.

The Monad tutorial hell is just because the Haskell community have been too busy circlejerking for 30 years straight to explain things using terminology software engineers understand. Thank god the creators of Rust and Lean weren’t so dense... A monad is just an interface that lets you encapsulate side effects in a convenient way. It lets you write imperative-looking code to glue your pure function moonshine together. The monad interface borrowed the name and laws from pure math, which is cool, because it means smarter people than us Grugs can prove things about this abstraction’s correctness and composability. Haskell shouldn’t be as hard as it is. It’s just that too much of the community is full of themselves and _terrible_ at explaining simple things.

so that's what it can be used for outside of whitepapers..

It means a bit more than that. A monoid is a triple (X, •, e) where • is an associative binary operation and e is the identity element. For example (Int, +, 0) is a monoid. A monad is an endofunctor M together with >>= (as you mentioned) and return :: a -> M a. The point is that if you define a monoid (X, •, e) in the category of endofunctors, you will find that • has the same type signature as >>= and e has the same type signature as return. Also, if you define a monad, then it is always a monoid too (in the category of endofunctors). So a monad is precisely a monoid in the category of endofunctors.

@@Miaumiau3333 Not quite. The monoidal product • would have the type • :: m (m a) -> m a in the category of endofunctors (using Haskell like types). You get bind (>>=) by combining the multiplication • with fmap (M) as `ma >>= f = join (fmap f ma)` > if you define a monoid (X, •, e) in the category of endofunctors The common names for the monoid triple are (T, μ, η) where T is the endofunctor itself, μ the multiplication natural transformation and η the identity natural transformation.

@@ViktorKronvall You're right, thanks for the corrections! • doesn't directly correspond to >>=, and I didn't mention natural transformations. I just wasn't sure how to explain things to someone who is not a category theorist.

I'll like to see that 💪

I came down the comments to find where F# will have been mentioned. The ugly brother of the lords language - C#

probably his idea of a good fp language

Those were the days before blue LED was invented.

​@@samsak1239You're talking about the green hackernoon uses, which is the text color of terminals back in the days we both remember. This specific green on the wired article is 🤢

Coming from a formal stats training, functional programming was always more intuitive and straight forward for me than OOP. It took me sooo long to think in an OOP way, and I still prefer functional programming, even if small elements of it like pure functions and having no side effects.

@@hamm8934 As a formal stats person, were you ever aware that R, like Haskell, was lazy-evaluated? One of the few languages to have a lazy evaluation strategy.

@@user-pe7gf9rv4m Love R ;) R was probably my first programming language I ever really got into. It has left it's mark on me because I'm the odd duck that thinks base 1 indexing is better for indexing as it doesn't break the 'pointing' metaphor of ordinality like 0 base does (I think 0 base is better for slicing/ranges, but for indexing and iterating, base 1 is superior). That said, I didn't know that about the lazy evaluation strategy. My use of R is quite high-level and primarily DS/analysis focused; I never learned much about the language implementation details. Very interesting, thanks for sharing! Also, for anyone out there reading this: R's DS ecosystem blows pythons out of the water for descriptive stats. It's not even close. Both the breadth and depth of R's regression packages is outstanding.

There's benefits to FP and there's a lot of useful ideas to come out of it, like the Functor utilities, like map, filter, etc. But there are some jobs where having a mutable state just makes things 10 times easier.

@@taragnor absolutely ! just for communication, if you wanna work with other people in IT that aren't deep into functional, pure functional is probably a terrible idea

Or J, Kona, Q, a+ ... you remember those. The source code looks like a bird walked across your keyboard. I stopped writing in J and Kona about 10 years ago. Most people don't have a clue about that stuff. I had only one contract with a bank guy that used J for a trading platforms. He wanted kona apps and query translated to J. I know he stopped persuing the migration and went back to paying KX Systems. J lang died or something. He was a J.P. Morgan guy.

He knows about it, just don't show him J and it's successors and he'll be fine.

FP is easy until you have to apply it in practice. People often tend to learn better when they can compare things to something they already know. You can't do that in FP beause almost everything is abstraction which stacks on top of more abstractions to the point people get confused to exhaustion. One great example of that is you're not gonna find a single person in the entire Haskell community which can give a satisfactory explanation as to what a monad is.

@@BrunodeSouzaLino FP is not only monads, though. There are dynamic functional programming languages, and if you use them, you only need to rewrite your brain to use functions as primary means of abstraction, and immutable "plain" structures like vectors and maps - no such need for this pile of abstractions that exist in Haskell, Coq, Idris, etc...

@@BrunodeSouzaLino Monads are not inherently FP. FP is mostly just a high-level programing language layer of abstraction over lambda calculus. Everything you model using Monads can be modelled in more fundemental/basic Haskell features/code. But certain patterns, we notice, become very repetitive and hence we group them into common concepts like Monads, Functors, etc. Thats about it. I wrote a full JSON parser in haskell without making any instances for my types in Monad, Functor or Applicative or any other fancy haskell word you may have heard.

@@BrunodeSouzaLino Here you go: A generic type that wraps a value and implements the "monad" contract (set of functions). When implemented, it allows you to map between wrapped values, combine them etc. It's a general programming pattern that has found its way into most typed languages now in some form. Its got a "jargon" name, but so does everything else. Strictly correct definition? No, I'm sure some academics just flipped a table reading that, but in practice its good enough.

@@Denominus That is what a monad does, not what it is.

I've never liked coroutines. They make so much less sense to me than kleisli arrow composition or other monadic functions.

Yeap; type system. Also, simplify: monads are a way to overload the semicolon ; operator from C.

Arbitrary operators can make programs hard to read for outsiders. And they make me create my own language-within-the-language, which prevents me from writing programs. I assume that part of the success of imperative languages come from their rigid syntax and structure, therefore highly predictable appearance to the reader. The language Elm has abandoned arbitrary operators. It combines the restrictiveness and low expressivity of imperative languages with the elegance of no curly braces and the questionable beauty of invisible function parameters (currying), and it sheds features with every release.

@@flupsiupsi yes; user-definable operators are double-edged sword, having them is a tradeoff. If you read too hard into them, it can be hard to read. Yet, they can also be very elegant to sometimes use as "programmable syntax" helping decompose complicated expressions into (combinations of) simpler ones - which is something imperative languages are poor at doing.

sounds like what she thought she loved she realized she actually didn't

Just say "I don't want to put in the effort to learn something new". That's fine. Nobody is after your imperative security blanket. You don't need to lie and claim that something that you don't understand yet is convoluted

@@worgenzwithm14z same can be said for OOP. It not the architecture that's bad, if you put in the effort to learn it it wouldn't be that bad...see what I did there?

​@chudchadanstud the difference is that OOP is not as complex as functional programming just for the existance of monads. OOP is very easily explained, and after a couple of years of using it in any industry gives you 99% of you want to know. If you want more, make a towerdefense or something aking with abstract classes ans w/e to make your types the business languaje. Is rrally not hard at all, just takes practice. FP is hard, and just practice is not enough. You have to actually study if you don't have the fundamentals. For OOP understanding what an instance is, is half of what you need to understand the rest of the concepts

Ironically, despite the fact that Haskell is exceptionally difficult to learn and write, it's not actually convoluted (though you can write convoluted code, as in all languages). The core of FP, lambda calculus, makes it so that you can very simply evaluate code bit by bit to figure out what's going on. Compare this to the call graphs that form in OOP; all of these objects which are easy to understand individually form a network that is unbelievably convoluted. For an example, look at the old LLVM docs which had all of those absurdly messy graphs. FP isn't convoluted, it's just difficult.

@@Slashx92 I think you forget the growing pains of learning OOP. Inheritance is an easy concept, but hard to master and can make for convoluted and difficult to diagnose bugs. How many patterns and best practices have been devised to help do OOP right? Dependency injection, inversion of control, SOLID principles, etc. How many guardrails have to be written to protect against null references? How many times did something get mutated unexpectedly because it was passed around by reference? How many GoF patterns did you have to learn? FP is hard also, but in different ways. The patterns that may work in OOP to solve a problem have their own solutions in FP. What makes FP better IMHO is by defaulting to what I consider sane language settings. Immutability by default, expressions instead of statements, automatic currying, returning results instead of exceptions, preference for pure functions and total functions, the Type system and discriminated unions, no NULL!!! As for monads, once you understand the concepts, they are applicable to all of the monad types, Result, Option, List, Reader, etc. Sure, it may be hard to grasp at first, but no harder than multi parent inheritance, method overloading, constructors/destructors, copy semantics, etc.

Yep, 100% agree. High level but compiles to machine code so also can be fast.

AND because people tell you that you need to fully understand the category theory behind monads

My highest math class was Level 2 Imaginary Mathematics. I was familiar with all the mathematical terms that Haskell uses. Haskell's implementation of the mathematical terms like monad, pure function, category theorem, functor, arrows, and other complex stuff is way off based. They pompously and incorrectly use the vocabulary to explain basic knowledge that we already use in OOP design. Its like Perl + Pompous. A regular programmer is not going to grok haskell and its documentation unless you go and relearn what the haskellers thinks that ish means. Haskell documentation and tutorials are like a pompous misinformation. If I didn't already know J, perl, APL c++, prolog, and have a physicist's understanding of math, then reading the Haskell documents would have been hell. I can imagine regular programmers just dropping out of learning Haskell at any detailed level. Haskell is so type involved that it can be used like a APL or mathematical programming languages for theorist and physicists. Other than that, Haskell is overkill. And it causes problems for real world situations. Most companies that I know who use Haskell, use it to weed out programmers just to keep trade secrets.

@@complexity5545 can you give an example of a Haskell typeclass or some other feature that uses a mathematical term as it name but with a totally different definition?

@@complexity5545 what the hell is Level 2 Imaginary Mathematics?

I think you might be. Ages ago I went to a job interview for one of the few programming jobs in the area, and ended up turning down the job because it would have been programming in object oriented Perl. I chose joblessness over Perl

Klappa

C++ templates are far harder.

I find most code hard to read if I haven't written it myself.

@@nangld Yeah, C++ is my day job, trying to figure out what the code I wrote yesterday does is harder than figuring out the haskell i wrote last year means. Signal-to-noise ratio is excellent. Especially compared to C++.

@iverbrnstad791 cpp here too. I feel the same

Though I'm sure it would take you 3 months to explain how the parser works.

This is the main reason to use Haskell. Compilers and parsers and transforming programming languages into another program language.

@@BrunodeSouzaLino well obviously he would not only have to explain the core parsing logic but also the Haskell part of the parser. I think if you have some level of familiarity with Haskell, you'll understand how it works pretty easly.

No surprise pandoc, a fucking parser and text file converter, as written in Haskell.

@@samuraijosh1595 But you see this is often the problem. You cannot explain Haskell to someone which is not familiar with Haskell, something which is possible in other languages.

I fully agree. It almost feels like a meeting point between the dev. time of something like Scala and TS, which I love. Quick to write and quick to read without being overly simple OR forcing you down one path.

I never heard of uiua before and immediately assumed correctly that it would be stack based

Or brainfuck

The entirety of the Iversonian languages are code golf level terse (in fact, one of their most common applications is code golfing).

I think that boils down to learning new and different ways of approaching programming that is vastly different from traditional imperative languages.

This is why I love F#. You got the whole .NET framework but can still go hard on FP

I like Scala. You can fall back to Java libraries.

@@ZombieJig F# is my favorite language. C# is not at all on the same level. 6 months using F#. More than a decade using C#.

@@fsharplovewhat kind of work can someone do with F#?

@@schmud143 "F# is goood for programming", fsharpforfunandprofit. It's good in DDD, complex logic modelling, scripts, data processing, concurrent or parallel processing Compared to C#: - more functional code, less object oriented empty/verbose code. => more robust code - light syntax, fewer keywords to use/know (no or almost no: return , new, public, static, void) - expressive syntax - DU, pattern matching, pipe operator, currying - syntactic sugar : computation expression. Create your DU or record put them in container (seq, list or whatever) and pipe them to functions and that's your code!

Hello and welcome to another programming session with mr. Zozin 😃 That is engrained in my head, awsome content by the way

@arkeynserhayn8370 agreed. Seeing his first few c videos is so uncanny because he is such a master today. It's incredible to see how much someone can learn in 3? years

@@nevokrien95 Not only that, he comes with most raw ideas, the type of ideas that one asks themselves "how he even thought about this project, even my own personal project ideas are not THIS "unconventional" ". In one of his videos he said the goal of his channel and doing all of these weird projects is to make programming interesting again, and i believe he definitely delivered that promise.

Didn't he leave haskell because of the tooling?

@Tomyb15 no idea but I highly doubt u move to c for tooling these days all of his tooling is self made. I think its a love for low level stuff u can see it in some of the early videos

I was going to say the SKS public key server for PGP (which had to be deprecated because nobody could be found to fix the fake key spam issue around 2019), but I just checked and despite usual forklore it's written in OCaml, not Haskell.

Pandoc is written in Haskell

xMonad. I miss it now that I don't use x11 any more. It had an optional config.hs file. You could load setups from people on the internet, and they were using extensions that seemingly changed the whole syntax of the language. Still, never impossible to understand.

Hasura

Most of my childhood games were written in it, Vic 20 etc.. it is a "If that is my only option, ok then :(" language.

@@ParabolicLabs You're barking up entirely the wrong tree

@@ParabolicLabs You might be _masturbatorily_ barking up the wrong tree, but you're barking up the wrong tree nevertheless. In a world filled with runtimes, react on the server, python and javascript everywhere, you lay the blame for poor performance at the feet of... C programmers? Seriously?

@@ParabolicLabs "Assembly is absolutely peak. I'm so tired of hearing people say you shouldn't learn assembly. This is precisely why modern software is so beyond bloated, slow, and takes up so much RAM. The sentence "BUT THE COMPILER IS BETTER AT IT THAN YOU ARE!" " That's what you said. This sentence only makes sense with reference to fairly low level programming, like C, C++, Fortran, Rust, Zig, etc. Own your words or don't say them at all.

Nobody went to the moon

Everyone memes on it, but in reality, it's really handy to know it, even if you don't directly use it, because it's fundamental knowledge transcends it's original language/distro.

more like gentoo.

You don’t need a special keyboard for Haskell like APL either

It's like looking at the face of God. "Yes, this was the correct way to do it"

I mean, I'm also a math nerd, and the Fibonacci one liner doesn't make me feel anything, because it's the probably the most simple recursion relation you could think of lol Literally just Fn = Fn-1 + Fn-2 (F1 = 1, F2 = 0) Like c'mon bro, there's gotta be a more impressive example than that

@@Reydriel what makes you gasp a little when seeing it in Haskell?

@@wezzelinator IDK haven't seen much of Haskell in general, I was just saying that recursive Fibonacci one-liner isn't exactly that impressive IMO, not helped much by the fact that it's also not very useful either

@@Reydriel probably not. But being able to express something like fibo so beautifully in a language made me go crazy when I first saw it. Infinite, representation of What Fibo is. Not pretend fibo where we construct something that Acts like fibo. But Fibo itself. "What else can I do with this?"

Things like this make me no longer think I understand categories. If I like programming little functions and calling em in a row in main (using C, or using c++ like C) then what style is that. Your avi rules btw

@@boredandagitated C would be procedural ( behavior and data are independent from each other ) imperative ( state can be mutated and shared ). Something like Haskell would be procedural functional ( state is minimized, immutable and not shared )

@@boredandagitated C is procedural imperative, Haskell is procedural functional, C++ is a thing and something like Java is object-oriented imperative.