HaskLUL

Recorded live on twitch, GET IN
Article
www.wired.com/story/inside-th...
By: Sheon Han | / sheonhan
My Stream
/ theprimeagen
Best Way To Support Me
Become a backend engineer. Its my favorite site
boot.dev/?promo=PRIMEYT
This is also the best way to support me is to support yourself becoming a better backend engineer.
MY MAIN YT CHANNEL: Has well edited engineering videos
/ theprimeagen
Discord
/ discord
Have something for me to read or react to?: / theprimeagenreact
Kinesis Advantage 360: bit.ly/Prime-Kinesis
Hey I am sponsored by Turso, an edge database. I think they are pretty neet. Give them a try for free and if you want you can get a decent amount off (the free tier is the best (better than planetscale or any other))
turso.tech/deeznuts

[@j_stach]

A monad is like a burrito that rolls itself then eats itself to make a new burrito

[@isodoubIet]

Now extend to explain the difference between functors and applicatives lol

[@ericjbowman1708]

Exactly! Perfect description of how xmonad twm works.

[@BrunodeSouzaLino]

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

[@opposite342]

this is the best monad explanation every wtf

[@sigmundwong2489]

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.

[@KeremyJato]

Never forget Dante's journey through the nine circles of torment in Hask-Hell

[@danielreed5199]

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

[@hugobcdesrosiers5689]

Survey: the Prime is secretly starting to learn Haskell and will become a fan within 3 months... >> YES | NO | I'm too scared to answer

[@jeremymcadams7743]

I'm too scared to answer

[@BrunodeSouzaLino]

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

[@weakspirit_]

NO

[@complexity5545]

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.

[@samuraijosh1595]

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

[@MrKlarthums]

John Backus led the team at IBM that implemented and released the first Fortran compiler back in 1957. Died back in 2007.

[@old_gaffer]

Backus was one of the og gigachads

[@ccgamedes33]

There is a Fortran '54

[@____uncompetative]

@@ccgamedes33 That's what I use.

[@aboliguu1168]

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

[@j3pl]

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.

[@lollertoaster]

Yes! This article was such a trip, I'm glad you are covering this. It's literally a guy going "I know Haskell, BTW".

[@sub-harmonik]

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

[@FourOf92000]

to understand the monad, one must become the monad >>= the world is a parameter, everything is declarative if you believe >>= the meta is terse and elegant, functions upon functions upon functions >>= a tall white fountain played.

[@user-pe7gf9rv4m]

a tall ivory tower played

[@tvvoty]

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

[@feschber]

this should be a metal song

[@max3446]

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

[@JohnDoe-my5ip]

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.

[@LunarLambda]

Monad is a monoid in the category of endofunctors isn't actually that hard to understand at its core the words are just impenetrable It just means (>>=) :: (a -> m b) -> m a -> m b

[@Miaumiau3333]

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.

[@ViktorKronvall]

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

[@Miaumiau3333]

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

[@VictorMenge]

prime writing f# when

[@ProjectVastness]

I'll like to see that 💪

[@Kane0123]

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

[@natebrown2805]

probably his idea of a good fp language

[@Redyf]

The true monad are the friends we make along the way

[@velorama-tkkn]

What I've learned from this article: it's OK if you're useless, as long as you're aesthetically pleasing.

[@robtrzci4365]

Bimbo programming is a thing?

[@dioneto6855]

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

[@danielreed5199]

"“Truck” came from the French word (troc) for “barter.” Originally, if you had no truck with somebody, you refused to trade with him or her" I presume the vehicle "Truck" has a similar etymology, due to it's ability to transport goods for trade, I speculate though.

[@SimGunther]

That green hurts my eyes. I'm probably the only HaskLUL programmer who despises that specific shade of green.

[@samsak1239]

Those were the days before blue LED was invented.

[@SimGunther]

​@@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 🤢

[@TosterCx]

The mic hinges are screaming for lubrication.

[@morgane3501]

look, you are right for 98% of people that they think they love functional programming but they don't, but that's not true for everyone. some people genuinely love functional programming, and i'm one of them. there is nothing more fun than writing increibly elegant functional that nobody else can read

[@hamm8934]

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.

[@user-pe7gf9rv4m]

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

[@hamm8934]

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

[@taragnor]

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.

[@morgane3501]

@@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

[@LuisM_Santana]

Is been a while since I laughed so much at reading/listening a tech article. Awesome

[@chudchadanstud]

>Hate OOP because its convoluted >FP is convoluted but still loves it

[@worgenzwithm14z]

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

[@chudchadanstud]

@@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?

[@Slashx92]

​@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

[@WHYUNODYLAN]

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.

[@benniecopeland7388]

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

[@StatixCinder]

Using Haskel is the equivalent of 'I stack cups the fastest' on your buffalo wild wings resume

[@replikvltyoutube3727]

Nobody tell Primagen about APL

[@complexity5545]

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.

[@Kiyoliki]

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

[@tamerogeny]

That dude is freakin' hilarious! I had a blast. Thanks, Prime.

[@danielreed5199]

"What you think you love, likely isn't what you love" .. that is terrible advice, I just told my wife that... now I am getting divorced.

[@robonator2945]

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

[@detaaditya6237]

Yeahh, that beauty thing is probably what drives me to write code in pipelines/railway in my personal projects. The code become insanely simple, pretty, pure, and composable, but doing it takes more time than ol'reliable imperative code.

[@canadiannomad2330]

Love it. I feel like it was written in the author's native language, humor included, then passed to an LLM to translate it, but with some fun instructions about maintaining flowery or technical words as close to the original as possible.

[@sirhenrystalwart8303]

I love you Prime. This was good.

[@hephestosthalays2700]

“There’s dozens of us! Dozens!”, TObias Funke

[@Denominus]

FP isn't nearly as difficult as people make it out to be, it just seems hard when your brain is wired to think differently already. Not a perfect analogy, but if your brain is hard wired to think in imperial units, you will struggle with metric and vice versa. The one you find easiest is the one you started with.

[@BrunodeSouzaLino]

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.

[@MauricioSzabo]

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

[@samuraijosh1595]

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

[@Denominus]

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

[@BrunodeSouzaLino]

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

[@jonathanjacobson7012]

M-W: Frisson comes from the French word for shiver which originates from the Latin word for friction. Definitely an orgasm.

[@senaarth7868]

had to create a college project with haskll studying the function paradigm.. wouldnt want it to my worst enemy

[@thesaintseiya]

okay but that ending bit was super motivating

[@kurtmayer2041]

a monad is really just a generic type with a continuation. Promise is a monad (Promise.resolve is pure and .then is bind); c++23 introduced monadic funcions on std::optional and std::expected, though the syntax for them sucks (it's all callbacks) (there are wrappers around these to imitate haskell's do notation with coroutines, which pleases me). but the biggest thing in haskell more languages should take inspiration from isn't necessarily monads, but the type system: higher kinded types and a deduction engine that tells you what functions can go in a place also arbitrary operators, those would be very nice to have sometimes

[@Ekce]

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

[@ulidtko]

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

[@flupsiupsi]

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.

[@ulidtko]

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

[@JackMudge]

Lisp was an *enormous* language in 1977, it wasn't quite ready for the ANSI standard but it was the Java of its day -- largely created for practical needs without much regard for theoretical purity. "pure" versions of it existed (one of which we have as Scheme today, for example), but Common Lisp and its predecessors take a thousand-page tome to fully describe.

[@chaoslab]

One of my favourites, many levels of epic-AGIN!

[@AzureFlash]

"The syntax was almost offensively terse" May I introduce you to Uiua

[@AndrewBrownK]

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

[@JohnDoe-my5ip]

Or brainfuck

[@Kiyoliki]

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

[@alexaustin6961]

Wait that's crazy I was looking at the Borgo compiler the other day to see how they built it lmao

[@ivanheffner2587]

Ok… I saw a “PERL” in the chat. I assume that was ironic, because I think I’m one of a couple dozen people who really enjoy Perl. Also: Contra and Battle Toads are both great platform games of their time. Legend of Zelda was a great open world RPG in the early years of video game consoles.

[@vinapocalypse]

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

[@user-hk3ej4hk7m]

About the comment of making your kids play elden ring. I had a similar obsession with rocket jumping on TF2, the first 20-40 hours is pure pain, but once you get the hang of it, you're flying all over the map, and it's also really hard to master. Being humbled constantly by a videogame can make you pretty resilient in other stuff without much risk. It's sad when you see people have to go through that irl without much of a safety net.

[@tempname8263]

Rust without borrow-checker is just BeefLang

[@t0mmy44h]

"no truck with" refusal of association

[@thegreenxeno9430]

"No truck with" No business with, won't stop for you Less common, more frequently used in traditional delivery businesses, rarely used elsewhere

[@rsin314159]

I can proudly say, I beat Battletoads as a kid. It took several years, but I did it. And I had the gaming magazine with the maps for it inside. That game was crazy hard, and the controls were bad AF.

[@cassandrasinclair8722]

I wrote a parser for python in Haskell for a course. Took about 3 days. In C or C++ it'd be 3 weeks.

[@BrunodeSouzaLino]

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

[@complexity5545]

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

[@samuraijosh1595]

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

[@victorgabr]

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

[@BrunodeSouzaLino]

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

[@gravisan]

Haskell programmers are on another level

[@elimgarak3597]

This whole article is one big r/programmingcirclejerk post

[@lucasteo5015]

do kotlin, easy to read procedural functional programming, it isn't even the language that is nice but actually the helper function they have out of the box for collections... filter, map, groupBy, associateBy, reduce, fold .... etc.... all those higher order functions

[@redwastaken3363]

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.

[@DoctorRainer]

Haskell is a simple language but it has extensions that make language infinitely extendable but you don't really need it. And Haskell is very high-level language, much more high-level than JavaScript to the point that it allows you to use math theory to solve problems on the level of expression and context of the language which is unachievable with something like JavaScript. The thing why people think it's difficult is because of some libraries written by nerds with insanely overcomplicated types but it's not Haskell's issue, those madmans would invent the same in JavaScript if they were to write it

[@RobHarrison]

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

[@feschber]

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

[@complexity5545]

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.

[@samuraijosh1595]

@@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?

[@FiveArc]

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

[@Saliferous]

Yes. Functional programming is hard as F to read. (joke intended)

[@airkami]

Klappa

[@nangld]

C++ templates are far harder.

[@danielreed5199]

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

[@iverbrnstad791]

@@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++.

[@visitante-pc5zc]

@iverbrnstad791 cpp here too. I feel the same

[@Veptis]

I never even looked at Haskell, but we did Prolog at university... Haven't had a use for it since tho.

[@possumcode]

A senior EE dude lectured me on C being bloated and ASM is the way to go (=

[@gownerjones1450]

Look Prime, I don't mind you fiddling with the mic but BY GOD put some oil on that boom arm.

[@GoddamnAxl]

I just started learning Haskell yesterday because a course at uni requires it… how timely

[@gnaarW]

Kinda unrelated (since Borgo was mentioned): did prime ever say something about goplus?

[@bastardferret869]

The thing with math is discoveries are always "useless" until they aren't.

[@johanngambolputty5351]

I so agree about elden ring, dark souls 3 kinda taught me that, I was a bit old to be learning that lesson, towards the end of my undergrad, but still.

[@nevokrien95]

One of my favorite KZbin programers (tsosen) moved from hasskle to c. The guy makes really high quality stuff u would never guess he used to write hasskle

[@arkeynserhayn8370]

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

[@nevokrien95]

@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

[@arkeynserhayn8370]

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

[@Tomyb15]

Didn't he leave haskell because of the tooling?

[@nevokrien95]

@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

[@bananaboye3759]

More OCaml please. I hate writing FP but watching you do it is great

[@MrZendor]

This was funny.. Heck if I could dump OO and just write one procedure from top to bottom that would be great.. And I do that on my own personal projects. You know, when no one is looking.. Yes I have put one button on a form in C# and wrote one entire procedure. But If I want to look smart and deliver actual production code that a company will pay me for. Well, that is another story. I dabbled with F# when it was new. And I can follow along looking at someone else write functional code. But it takes me more clock cycles to get there. That could be my age though. Heck I started my programming life with Delphi writing pascal..

[@fistoflegend7846]

Haskell is garbage and functional programming is garbage. If I cant pass a size_t and a pointer to an array of pointers to structs which hold pointers to different structs to a function which casts the whole chunk of data to an array of 8 bit integers of a size indicated by the size_t and returns a pointer to that new array because the language thinks that's "dangerous" then I have no use for that language.

[@LordHonkInc]

"Is Haskell is the Evil Dead 2 of programming languages"? I'd compare it more closely to The Room tbh :P

[@doctorgears9358]

The only problem Prime runs away from: Making functional programming fun to watch

[@MrEo89]

QED == “quod erat demonstrandum” Translated it means: “what was to be demonstrated.”

[@trolololo720]

16:00 It's a monoid in the category of endofunctors, with the product replaced by composition of endofunctors and unit set by the identity endofunctor. What else is there to explain

[@gtgunar]

Haskell, Assembly, APL. 3 languages, that really deserve to be learned, becaulse of the considerations and new perspectives they bring. Ask yourself the question, if you could learn any languages instantly, at the tradeoff that after that you can't use that lang, which one would it be? What are the languages that are not a waste of time even if you never use them directl?

[@Kiyoliki]

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

[@thejoe7682]

Lisp

[@adamwarvergeben]

Haskell is useful to look nice on paper/in papers

[@danielAgorander]

Hey, fav lang from early 70's - B. It's like C, indeed it begat C, but C is all kinds of fancy in comparison. Since, you know, in B there is only the one single data type: the pointer. :D

[@azeek]

Let's go the primerorgen

[@jumhig]

Sounds like this Haskell thing has the "Forth Curse".

[@bocckoka]

As a Blizzard employee once said, 'you think you want it, but you don't'. Turns out we do.

[@vilian9185]

hell, i don't use google anymore, but seeing google show the most irrelevant results possible was painful

[@DylanMatthewTurner]

I love Haskell, but it's just not practical to use. The library support is too small and too imperative.

[@ZombieJig]

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

[@luckyLaserface]

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

[@fsharplove]

@@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#.

[@schmud143]

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

[@fsharplove]

@@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!

[@mage3690]

"No truck with" is Tom Sawyer/Mark Twain level old. The only reason I know this is because I read the unabridged version.

[@leonf8199]

top-to-bottom easy-to-read are actually words used for functional programming in my world lol

[@jackrorystaunton4557]

"contra, battletoads"

[@SlammerSimming]

What do you mean we shouldn't write assembly? It was literally humanity's peak. We went to the moon with it, and it runs on fighter jets like the F35

[@danielreed5199]

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

[@isodoubIet]

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

[@isodoubIet]

@@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?

[@isodoubIet]

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

[@rusi6219]

Nobody went to the moon

[@GeorgijTovarsen]

I freaking love Haskell and the 0 projects that I made with it

[@mgr1282]

Cardano is written in haskell and had no down time. Solana is written in Rust and had lots of down times.

[@Corza]

Prime............................................... oil your microphone stand.

[@TheQxY]

I was initially very interested in Haskell (and functional programming as a whole) coming from a physics background. But then I found out that these functional ways of doing things are actually just almost always slower abstractions, and it obscufates what the computer actually needs to do. So, it hides control flow and introduces unnecessary abstractions. These are exactly the opposite paradigms of Go, which has become my favourite language.

[@cassiothird]

Humans like to think the solutions/answers are always beautiful, simple or both, but in many cases that's not possible to achieve and pursuing that belief will lead you to worse solutions

[@bjorntrollowsky4279]

21:08 The "useless intellectual excercise" of yesterday will become the "useful" and "expedient" method of tomorrow.

[@EvgenyVinnik]

pure gold

[@elirane85]

I've only recently switched from my obsession with FP to low level system programming with Rust. Oh man, now I have to go back?

[@mybeme9130]

"French is Rated." -- Some guy in chat. lol

[@Simone-uu8ne]

My Prog1 module in uni was Pascal + ANSI C, FML

[@ryanrobbins3846]

I'm going to loose sleep thinking about 🤯🤬🤬🤬 BATTLE TOADS!

[@AuratticStride]

One thing I think you should take a look at is a video called "I used elm in production and it cost me my job"

[@blarghblargh]

My brother in Vim: oil that chair!

[@stephanreiken9912]

There needs to be a programming language Spaghetti.

[@fugoogle_was_already_taken]

Functional programing is very good at certain class of problems. It also has very practical and beautiful tools for those who understand it. But thats also its biggest flaw; some concepts are not yet very known and for many people they are hard to understand. However, Haskell is still more readable then APL xdd

[@JohnDoe-my5ip]

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

[@user-qh5zw3ex5z]

QED is what you write at the end of a math proof. Stands for quod erat demonstrandum which is latin for that which was to be demonstrated.

[@74Bagas]

it's so good,

[@ErazerPT]

Damn... Prime made me revisit the past and... now i understand why i like C# so much. I liked Turbo Pascal's Object Pascal a lot back when. And C# isn't all that dissimilar from a birds eye view. Now Java... it's like they took OP and ran wild with as much degeneracy as they could...

[@3a146]

Dont' worry, I am already working Agda, or Cubical Agda more precisely.

[@dapperpanguin994]

Why is this article written like a Hasbin Hotel character wrote it

[@InfiniteQuest86]

Oh man if you watched Evil Dead 2, you should definitely watch the original spider man movies with them. Made by the same director. Just truly amazing.

[@Lue30499]

a monad is a monoid in the category of endofunctors

[@SJohnTrombley]

If the (theoretically infinite) Fibonacci one liner doesn't make you feel something, Haskell honestly might not be for you, and that's okay. I personally find it incredibly elegant, but I'm also a math nerd, so the fact that it directly expresses the inherent recursion in the Fibonacci sequence is something I find beautiful.

[@wezzelinator]

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

[@Reydriel]

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

[@wezzelinator]

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

[@Reydriel]

@@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

[@wezzelinator]

@@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?"

[@VikramMahendru]

Petition to get prime to play the new COD hardcore swat thingy in hardcore mode just for the comments at 5:10

[@andrewdunbar828]

I've never heard the phrase ThePrimeTime.

[@boredandagitated]

I once got kicked in the monads

[@Jabberwockybird]

22:10. Cool Ranch is beautiful and truly awesome tasting

[@filipbystricky7301]

It's incredibly useful to understand functional programming as it helps you write better code even in procedural/mixed-paradigm languages. Another thing that I don't hear as much is how great it is for teaching students how to program for the first time. You can get extremely far without monads, in fact with a very small number of basic concepts. Meanwhile, procedural languages feel simple once you have some experience, but to get started you need a lot more concepts, like mutation: you have to either learn about the foot-guns of shared mutable state, or learn about lifetimes and borrow checking. I think it's great to learn about those things too, I just think it's underappreciated how hard it can be for beginners.