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.
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.
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....
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.
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.
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.
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.
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
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
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
@@anarchymatt 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.
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.
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 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 And here we see the trick to the self-fulfilling prophecy of "noone can give me a satisfactory explanation": you're the sole arbiter of satisfaction and decided, sight unseen, not to be satisfied. It's made easier by not explaining your expectations, so you can stake out new goal posts every time any attempt occurs. Monad comes from greek, same root as mono. In APLs monadic functions take one argument. It's the same in Haskell, used to thread one singular state through an ordered chain of functions and/or actions. We can use them to make decisions about computation, like how Maybe or Either can shortcut (replacing exceptions), STM can retry, and IO can interact and delay. IO does that by leaving the confines of pure computation. Lifting out only the parts that need it is one of the benefits of the monad, and another is to indicate where these actions are possible. Personally I enjoy the fact that Haskell teaches me terminology for concepts that were harder to consider without names.
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
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.
"“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.
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.
@@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 🤢
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
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.
@@FiveArc You know how you learned that the square root of -1 is the imaginary number [ i ]. Well, there are even more complex numbers and associated maths. Its the study of advanced complex numbering systems and the related matrix and multi-dimensional mathematics. You apply Sir Issac Newton type of maths, trig, and calculus to these imaginary axes. Physicists and (LoL) stock analysts use it to find patterns and predict imaginary axes of space-time, dimensions, and associated pictures. I took the class to learn the vocabulary: like real numbers, imaginary numbers, imaginary real numbers, complex numbers, irrational complex numbers. There are different types of complex numbers because you can get different combinations of adjectives and adverbs and verbs and when to apply some mathematical functor or monad, dyad, tetrad, and other crazy out of this world grammar. Haskell stole/borrowed that wording from this area of math. Haskellers also implement and explain it wrong through out their documentation. They have a false understanding of grammar. So you read Haskell documents sometimes and you have to figure out hwo they interpolate or defined their idea when they use the word. But haskell has a type system that lets you create a OOP representation of all those complex numbering combinations. I went to a college that is/was one of the few colleges in the USA that had a live Nuclear Plant on campus (so students could learn). I hope I don't Dox myself. Level 2 was meant for first year graduates seeking their Doctorate. I took it in my junior year in college. I secretly interned with a NASA sub-contracter. One of my semi-coworker mentors told me to take it, so that I could understand how to program the 3D modeling software and applying it to theories. He was a Nuclear Engineer Graduate getting his Doctorate and we both worked for the same NASA (rocket) contractors. At the time, he was the only nuclear engineer that graduated in the last 7 years of the university. He decided to get a Doctorate just to tack on more possible income. Complex math is used alot in mission critical emulators just to predict possible catastrophic failures and to avoid them. ITs also used to create possible multi-dimensional modeling. Today we use it with Cuda/nvidia GPUs to make videos, pictures, and find patterns. Any physicists and CSC programmer that use Haskell on a daily basis for complex mathematics, are on another level of WTF. Its a deep dive on just how fragile and vulnerable you are especially if you riding a supersonic rocket. I think some astronomers use it to make "black hole" pictures. I know some J.P. morgan analyst who use complex numbering systems. Complex numbers are useful when you get stumped in a regular math algorithm, so you create a whole imaginary axis and then apply matrix math to better understand your problem. Its another level of WTF. I also used complex numbers in DSP audio programs to emulate reverbs; it got weird. AI uses complex numbering now. Which is why Nvidia GPUs are ~$2000 now.
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.
Learning Clojure and Elixir/erlang (not the languages, but their reasoning, and seeing how they solve certain things that inspired their creation) has upped my python and java game immensely.
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.
7:46 I think that "bloated" might be in relation to the Von Neumann style of programming languages. I think that it is a talk about alternative styles of conceptualization for programming languages.
In fact, I have just checked the wikipedia for Von Neumann style of programming languages, and John Backus appears as a critic of the schism created by it. In fact, the complete title is "Can programming be liberated from the von Neumann style? a functional style and its algebra of programs".
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.
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.
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
@@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!
FWIW Haskell Curry was dead when the programming language came out, so he wasn't offended. His widow was alive and said her husband hated his first name so you have that. BTW he was wrong the problem with "Curry" at the time was not the food item. Rather Rocky Horror Picture Show was still popular and Tim Curry was the referant so they got lots of "Let's do the time warp again" type jokes.
So far, what I have understood about Monads, Applicatives and Functors... Is that is a way to organize the code to operate over the content of data structures in a compostable and reliable way... So for each data structure that you want to operate over its content with simple functions in a coherente composable and reliable way, you define a bunch of functions over that data structures (like fmap for functors and bind for monads) ... So that you can rely on the compiler to help you to stay coherent all the way and to not make mistakes while operating over the content of the selected data structures...
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?
Assembly is more of a category than a language. For instance, PIC14 assembly has more in common with 6502 assembly than PIC32 assembly, and pretty much all they share with GA144 assembly is that they have steps. As for APL, I've looked at it some but I think I'm fairly satisfied learning BQN instead. Same family, but more regular syntax and different glyph selection. Is the base assumption here that everyone starts with an Algol family language? LISP is an excellent suggestion, though you can make do with Scheme. I'd also throw in Forth, for how it relates directly to what computation is possible and how simple a compiler can be, while still allowing to grow your language to any task.
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.
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 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?"
@@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++.
8:00 To answer your question: PL/1 "Programming Language 1". IBM attempt to make the programming language to end all programming languages. As far as I know there is no compiler who ever implemented to full PL/1 standard.
8:00 In 1970 Pascal, Basic, Forth, Cobol, Lisp, B were afaik the only general purpose programming languages to exist aside Algol, Fortran. However in shortly after in 1972 C, Prolog & Scheme came around. (I'm leaving out the first shell scripting language which was invented in 1971 because while it technically is a general purpose programming language, it's impractical to do so).
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
Monad are composable units of computation. You can pass it around (with state). You can map over it. You can join them together. Other languages (including JS) imitate certain aspects of Monad but none can do it as wholly as Haskell, which leads to misunderstanding and confusion about the concept of monad itself.
@@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.
@@BrunodeSouzaLino Yes you can. There are values including functions, and we can thread things together using monads, which is useful to interact. It's people stuck in a rut (e.g. that insist class must mean struct, or code must be sequential) that decide it's hard.
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
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.
@@flupsiupsi Hoogle helps heaps with arbitrary operators, and being able to read the source code of the operator isn't all that hard, the issue I find is writing code with it and trying to figure out what the evaluation order is mentally, It also feels like traits could make them far worse. I was quickly hooked when I first saw Parsec, didn't know what the operators did, but definitely understood the code examples.
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.
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.
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
@@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.
"co-X" is category theory-ese. It's kind of like the way "and" and "inclusive or" are duals of each other (see De Morgan's laws for an example). If you have a category, if you flip all the arrows you get another category...the dual of a category that defines an algebra defines a coalgebra. (BTW, it's pronounced /von NOY-man/.)
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
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
It's been over 20 years and there's not a single person in the entire Haskell community which can explain what a monad is without requiring you to either know category theory or already know what it is. Or by using weird analogies which cannot be abstracted using real life examples. It's like teaching calculus to a person who doesn't know how to count.
Well, "explaining" is a social activity, there isn't the 1 correct way to do it. And then, the more abstract you go, the harder it gets to skip steps; you're very right there. Say, can anyone explain what the heck is a Ring, or a Field, or a Lattice ?.. Sure, the definitions are simple; but defining ≠ explaining. A prerequisite for "explained" to happen, is that the recipient had met multiple superficially-dissimilar reformulations of the same structure in different contexts - and then gets help with revealing the common structural pattern being repeated. Then one "groks" the particular abstraction and learns the canonical name for it. And Monad is like that, it's an abstract algebraic structure of Functor + two operations.
A monad is just an interface with convenient properties for allowing you to glue together code with side effects without infecting your pure functions. Haskellers just love overcomplicating simple things with denser mathematical jargon than Coq or Lean users would. Haskell is a victim of its community’s extreme propensity for circlejerking about how smart they are. It could’ve been Rust 15 years sooner, I swear. It’s really not that much more complicated than Scheme, except for the community’s needless gatekeeping.
Unfortunately we are nowhere near overcoming the Von Neumann bottleneck: it will take a lot more than adopting a few styles. It will take an overall hardware redesign, in fact.
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.
This was not a good article. Is Wired at fault for not expecting better from their writer? Or am I at fault for expecting "Wired" to do better? Haskell is a niche language that is very very good at very specific things. Occasionally, it's the only language with a mature solution for solving your specific problem. Mercifully, that design space is shrinking. Still, Haskell is worth learning because it's a good excuse to teach yourself how to recognize, think about, and handle those types of problems. Writing something like Pandoc in C++ or Javascript would be miserable. Same thing with making certain kinds of DSLs or certain kinds of rapid prototypes. Niche use cases, sure. But it's worth having some basic familiarity because sooner or later you end up faced with a niche problem and you don't want to be the idiot who doesn't even realize he's looking at a pentagonal peg.
P.S. Shame to hear that the OCaml / functional programming stuff wasn't popular. Those are ideas that more young programmers need to understand because they are only going to become more relevant with time. You can't go fast on modern hardware with a hand-written loop anymore. CPUs fake it because the hardware is actually optimized only for certain patterns. Good GPU libraries assume you were thinking functionally when you wrote your code. And the special purpose hardware on the SoCs that power phones and laptops is inherently functional -- that's why it's fast and power efficient. I guess web stuff is layers and layers removed from "crunch numbers on GPU", but "back in my day" we were expected to know how everything worked down to the hardware. And with portable devices and special purpose hardware only getting more popular, someone is going to have to know how to make things work.
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.
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
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 think "no truck with" is brittish for disapproving or not wanting anything to do with something. The only place ive seen it is in discworld novels though. QED is short for quod erat demonstrandum, and means I have shown what i intended to. This is a common way of ending math proofs.
Haskell becoming relevant? Yeah that’s definitely a side effect… Maybe I should give the language a try, I have been writing emacs lisp lately and while what I write is rarely pure or functional, the rare cases are interesting to write.
I mean sure, you're mocking the code for taking ages longer to write. But then in other videos you'll talk about how you don't like functions spanning more than four lines because of "locality of code" or something. Well the thing about a haskell function is that you get that exact locality because its way more simple to simply put 100 lines of code in one file, but not really so much for 1000-2000 lines of code--which for a tool like a json parser I can believe haskell would have so much more brevity. Sure, it might be more difficult to understand how things are working under the hood because basically every single thing under the hood is a function call curried together. There is way more info in that 100 lines of code, which is why the more procedural approach (C) is going to be way more lines, but I would expect C code to generally compile to many more statements than it consisted of before it was compiled (although, maybe if the optimization is way better than I think I could see how it could be less). Either way, the idea is to try and simplify the instructions to us. Computer code is the attempt to command an inanimate object to do something you want it to do. I think some times we forget that the code we write isn't just for the machines but also for ourselves. I'm not using haskell now, and I wouldn't use it for large team projects where I suspect lots of other people will be working with it. But I will definitely use it for my personal projects because I'm the best one who understands how I think about the code that I'm writing for my future self to be able to come back and understand how I made that inanimate thing do what I wanted it to do. Its a great language, but because you're packing so much information into such a little space, its kinda difficult to work with other people in it. The nicest thing about trying to learn more about haskell was the discouragement they all give when you're having a problem: "what you don't understand that?" and I should respond OF COURSE I DIDN'T WRITE IT! You got to remember who your audience is sometimes.
One of my favorite TH-cam programers (tsosen) moved from hasskle to c. The guy makes really high quality stuff u would never guess he used to write hasskle
@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.
@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 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.
"simple procedural C-like code, that's easy to read, top to bottom, in and out, easy... easy" until you realize that you're keeping on debugging and fixing of a mid grade software for years, and it's your reality of a "new normal"
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..
Wired may not be the best source on programming languages. And "bloat" meant something different in 1977 than it does today. Emacs was considered "bloaty" back in the 80s. Rust's big failing is its borrow checker, and I spent most of my time trying to satisfy that vs. work on the problem at hand. Now, I do Haskell. And I like it.
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.
A monad is like a burrito that rolls itself then eats itself to make a new burrito
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 thing with math is discoveries are always "useless" until they aren't.
i think quaternions are a good example of this
Ricatti equation.
@@darkscholar7 Nobody thought fields and polynomial rings were of any use.
Then cryptography came along...
@@Finkelfunk nobody thought math in higher dimensions has any use. Then ML came along...
@@mb2776 which ML are you talking about? Machine learning or the programming language?
John Backus led the team at IBM that implemented and released the first Fortran compiler back in 1957. Died back in 2007.
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.
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
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.
NO
Never forget Dante's journey through the nine circles of torment in Hask-Hell
The 8th circle(fraud) is for bad programmers apparently, according to GPT.
Yes! This article was such a trip, I'm glad you are covering this. It's literally a guy going "I know Haskell, BTW".
so that's what it can be used for outside of whitepapers..
Haskell is hard because programmers are mathematicians who are bad at math.
if that was true, then mathematicians were programmers who were bad at programming, and who . . . instead of using Haskell, would use Curry instead.
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.
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.
The true monad are the friends we make along the way
prime writing f# when
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
didnt he write some ocaml? isnt that basically the same?
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.
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
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
>Hate OOP because its convoluted
>FP is convoluted but still loves it
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
@@anarchymatt 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.
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.
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 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.
@@BrunodeSouzaLino And here we see the trick to the self-fulfilling prophecy of "noone can give me a satisfactory explanation": you're the sole arbiter of satisfaction and decided, sight unseen, not to be satisfied. It's made easier by not explaining your expectations, so you can stake out new goal posts every time any attempt occurs.
Monad comes from greek, same root as mono. In APLs monadic functions take one argument. It's the same in Haskell, used to thread one singular state through an ordered chain of functions and/or actions. We can use them to make decisions about computation, like how Maybe or Either can shortcut (replacing exceptions), STM can retry, and IO can interact and delay. IO does that by leaving the confines of pure computation. Lifting out only the parts that need it is one of the benefits of the monad, and another is to indicate where these actions are possible.
Personally I enjoy the fact that Haskell teaches me terminology for concepts that were harder to consider without names.
The mic hinges are screaming for lubrication.
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
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.
"“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.
What about use of "truc" to mean "thing" in French? Is that similar etymology?
Using Haskel is the equivalent of 'I stack cups the fastest' on your buffalo wild wings resume
Haskell is the Arch of programming languages.
I know Haskell, BTW.
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.
What I've learned from this article: it's OK if you're useless, as long as you're aesthetically pleasing.
Bimbo programming is a thing?
The opposite is also true, look at C++.
@AndreiGeorgescu-j9pFar more practical than most languages? Ok... But far more practical than every other language???
That green hurts my eyes. I'm probably the only HaskLUL programmer who despises that specific shade of green.
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 🤢
This whole article is one big r/programmingcirclejerk post
Is been a while since I laughed so much at reading/listening a tech article. Awesome
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
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 what the hell is Level 2 Imaginary Mathematics?
@@FiveArc You know how you learned that the square root of -1 is the imaginary number [ i ]. Well, there are even more complex numbers and associated maths. Its the study of advanced complex numbering systems and the related matrix and multi-dimensional mathematics. You apply Sir Issac Newton type of maths, trig, and calculus to these imaginary axes. Physicists and (LoL) stock analysts use it to find patterns and predict imaginary axes of space-time, dimensions, and associated pictures. I took the class to learn the vocabulary: like real numbers, imaginary numbers, imaginary real numbers, complex numbers, irrational complex numbers. There are different types of complex numbers because you can get different combinations of adjectives and adverbs and verbs and when to apply some mathematical functor or monad, dyad, tetrad, and other crazy out of this world grammar. Haskell stole/borrowed that wording from this area of math. Haskellers also implement and explain it wrong through out their documentation. They have a false understanding of grammar. So you read Haskell documents sometimes and you have to figure out hwo they interpolate or defined their idea when they use the word. But haskell has a type system that lets you create a OOP representation of all those complex numbering combinations.
I went to a college that is/was one of the few colleges in the USA that had a live Nuclear Plant on campus (so students could learn). I hope I don't Dox myself.
Level 2 was meant for first year graduates seeking their Doctorate. I took it in my junior year in college. I secretly interned with a NASA sub-contracter. One of my semi-coworker mentors told me to take it, so that I could understand how to program the 3D modeling software and applying it to theories. He was a Nuclear Engineer Graduate getting his Doctorate and we both worked for the same NASA (rocket) contractors. At the time, he was the only nuclear engineer that graduated in the last 7 years of the university. He decided to get a Doctorate just to tack on more possible income.
Complex math is used alot in mission critical emulators just to predict possible catastrophic failures and to avoid them. ITs also used to create possible multi-dimensional modeling. Today we use it with Cuda/nvidia GPUs to make videos, pictures, and find patterns. Any physicists and CSC programmer that use Haskell on a daily basis for complex mathematics, are on another level of WTF. Its a deep dive on just how fragile and vulnerable you are especially if you riding a supersonic rocket. I think some astronomers use it to make "black hole" pictures. I know some J.P. morgan analyst who use complex numbering systems. Complex numbers are useful when you get stumped in a regular math algorithm, so you create a whole imaginary axis and then apply matrix math to better understand your problem. Its another level of WTF. I also used complex numbers in DSP audio programs to emulate reverbs; it got weird. AI uses complex numbering now. Which is why Nvidia GPUs are ~$2000 now.
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.
QED == “quod erat demonstrandum”
Translated it means: “what was to be demonstrated.”
Learning Clojure and Elixir/erlang (not the languages, but their reasoning, and seeing how they solve certain things that inspired their creation) has upped my python and java game immensely.
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.
"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.
sounds like what she thought she loved she realized she actually didn't
7:46 I think that "bloated" might be in relation to the Von Neumann style of programming languages. I think that it is a talk about alternative styles of conceptualization for programming languages.
In fact, I have just checked the wikipedia for Von Neumann style of programming languages, and John Backus appears as a critic of the schism created by it.
In fact, the complete title is "Can programming be liberated from the von Neumann style? a functional style and its algebra of programs".
The only problem Prime runs away from: Making functional programming fun to watch
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.
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.
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
I love Haskell, but it's just not practical to use. The library support is too small and too imperative.
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!
okay but that ending bit was super motivating
FWIW Haskell Curry was dead when the programming language came out, so he wasn't offended. His widow was alive and said her husband hated his first name so you have that. BTW he was wrong the problem with "Curry" at the time was not the food item. Rather Rocky Horror Picture Show was still popular and Tim Curry was the referant so they got lots of "Let's do the time warp again" type jokes.
So far, what I have understood about Monads, Applicatives and Functors... Is that is a way to organize the code to operate over the content of data structures in a compostable and reliable way... So for each data structure that you want to operate over its content with simple functions in a coherente composable and reliable way, you define a bunch of functions over that data structures (like fmap for functors and bind for monads) ... So that you can rely on the compiler to help you to stay coherent all the way and to not make mistakes while operating over the content of the selected data structures...
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?
I think that boils down to learning new and different ways of approaching programming that is vastly different from traditional imperative languages.
Lisp
Assembly is more of a category than a language. For instance, PIC14 assembly has more in common with 6502 assembly than PIC32 assembly, and pretty much all they share with GA144 assembly is that they have steps.
As for APL, I've looked at it some but I think I'm fairly satisfied learning BQN instead. Same family, but more regular syntax and different glyph selection.
Is the base assumption here that everyone starts with an Algol family language?
LISP is an excellent suggestion, though you can make do with Scheme. I'd also throw in Forth, for how it relates directly to what computation is possible and how simple a compiler can be, while still allowing to grow your language to any task.
M-W: Frisson comes from the French word for shiver which originates from the Latin word for friction.
Definitely an orgasm.
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.
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?"
Yes. Functional programming is hard as F to read. (joke intended)
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
8:00 To answer your question: PL/1 "Programming Language 1". IBM attempt to make the programming language to end all programming languages. As far as I know there is no compiler who ever implemented to full PL/1 standard.
8:00 In 1970 Pascal, Basic, Forth, Cobol, Lisp, B were afaik the only general purpose programming languages to exist aside Algol, Fortran. However in shortly after in 1972 C, Prolog & Scheme came around. (I'm leaving out the first shell scripting language which was invented in 1971 because while it technically is a general purpose programming language, it's impractical to do so).
“There’s dozens of us! Dozens!”, TObias Funke
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
Monad are composable units of computation. You can pass it around (with state). You can map over it. You can join them together. Other languages (including JS) imitate certain aspects of Monad but none can do it as wholly as Haskell, which leads to misunderstanding and confusion about the concept of monad itself.
That dude is freakin' hilarious! I had a blast. Thanks, Prime.
I wrote a parser for python in Haskell for a course. Took about 3 days. In C or C++ it'd be 3 weeks.
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.
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.
@@BrunodeSouzaLino Yes you can. There are values including functions, and we can thread things together using monads, which is useful to interact. It's people stuck in a rut (e.g. that insist class must mean struct, or code must be sequential) that decide it's hard.
"The syntax was almost offensively terse" May I introduce you to Uiua
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).
Cardano is written in haskell and had no down time.
Solana is written in Rust and had lots of down times.
"No truck with"
No business with, won't stop for you
Less common, more frequently used in traditional delivery businesses, rarely used elsewhere
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
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.
@@flupsiupsi Hoogle helps heaps with arbitrary operators, and being able to read the source code of the operator isn't all that hard, the issue I find is writing code with it and trying to figure out what the evaluation order is mentally, It also feels like traits could make them far worse. I was quickly hooked when I first saw Parsec, didn't know what the operators did, but definitely understood the code examples.
Haskell programmers are on another level
Nobody tell Primagen about APL
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.
haskell is the kind of language that language designers love
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.
wasnt haskell heavily used in the backend of Yahoo
A senior EE dude lectured me on C being bloated and ASM is the way to go (=
As a Blizzard employee once said, 'you think you want it, but you don't'. Turns out we do.
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
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
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
"no truck with" refusal of association
hell, i don't use google anymore, but seeing google show the most irrelevant results possible was painful
Kinda unrelated (since Borgo was mentioned): did prime ever say something about goplus?
"co-X" is category theory-ese. It's kind of like the way "and" and "inclusive or" are duals of each other (see De Morgan's laws for an example). If you have a category, if you flip all the arrows you get another category...the dual of a category that defines an algebra defines a coalgebra. (BTW, it's pronounced /von NOY-man/.)
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
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
You don’t need a special keyboard for Haskell like APL either
It's been over 20 years and there's not a single person in the entire Haskell community which can explain what a monad is without requiring you to either know category theory or already know what it is. Or by using weird analogies which cannot be abstracted using real life examples. It's like teaching calculus to a person who doesn't know how to count.
Well, "explaining" is a social activity, there isn't the 1 correct way to do it. And then, the more abstract you go, the harder it gets to skip steps; you're very right there.
Say, can anyone explain what the heck is a Ring, or a Field, or a Lattice ?.. Sure, the definitions are simple; but defining ≠ explaining. A prerequisite for "explained" to happen, is that the recipient had met multiple superficially-dissimilar reformulations of the same structure in different contexts - and then gets help with revealing the common structural pattern being repeated. Then one "groks" the particular abstraction and learns the canonical name for it. And Monad is like that, it's an abstract algebraic structure of Functor + two operations.
A monad is just an interface with convenient properties for allowing you to glue together code with side effects without infecting your pure functions.
Haskellers just love overcomplicating simple things with denser mathematical jargon than Coq or Lean users would.
Haskell is a victim of its community’s extreme propensity for circlejerking about how smart they are. It could’ve been Rust 15 years sooner, I swear. It’s really not that much more complicated than Scheme, except for the community’s needless gatekeeping.
I freaking love Haskell and the 0 projects that I made with it
Unfortunately we are nowhere near overcoming the Von Neumann bottleneck: it will take a lot more than adopting a few styles. It will take an overall hardware redesign, in fact.
Wait that's crazy I was looking at the Borgo compiler the other day to see how they built it lmao
You know you learnt a language/runtime, when you personally don't feel you have to use it anymore to leverage it's ideas.
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.
I never even looked at Haskell, but we did Prolog at university... Haven't had a use for it since tho.
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.
This was not a good article. Is Wired at fault for not expecting better from their writer? Or am I at fault for expecting "Wired" to do better?
Haskell is a niche language that is very very good at very specific things. Occasionally, it's the only language with a mature solution for solving your specific problem. Mercifully, that design space is shrinking. Still, Haskell is worth learning because it's a good excuse to teach yourself how to recognize, think about, and handle those types of problems.
Writing something like Pandoc in C++ or Javascript would be miserable. Same thing with making certain kinds of DSLs or certain kinds of rapid prototypes. Niche use cases, sure. But it's worth having some basic familiarity because sooner or later you end up faced with a niche problem and you don't want to be the idiot who doesn't even realize he's looking at a pentagonal peg.
P.S. Shame to hear that the OCaml / functional programming stuff wasn't popular. Those are ideas that more young programmers need to understand because they are only going to become more relevant with time.
You can't go fast on modern hardware with a hand-written loop anymore. CPUs fake it because the hardware is actually optimized only for certain patterns. Good GPU libraries assume you were thinking functionally when you wrote your code. And the special purpose hardware on the SoCs that power phones and laptops is inherently functional -- that's why it's fast and power efficient.
I guess web stuff is layers and layers removed from "crunch numbers on GPU", but "back in my day" we were expected to know how everything worked down to the hardware. And with portable devices and special purpose hardware only getting more popular, someone is going to have to know how to make things work.
One of my favourites, many levels of epic-AGIN!
I love you Prime. This was good.
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.
skill issue
Okay dude.
yes, haskell is garbage
collected.
and also garbage
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
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 think "no truck with" is brittish for disapproving or not wanting anything to do with something. The only place ive seen it is in discworld novels though.
QED is short for quod erat demonstrandum, and means I have shown what i intended to. This is a common way of ending math proofs.
Rust without borrow-checker is just BeefLang
Haskell becoming relevant? Yeah that’s definitely a side effect…
Maybe I should give the language a try, I have been writing emacs lisp lately and while what I write is rarely pure or functional, the rare cases are interesting to write.
had to create a college project with haskll studying the function paradigm.. wouldnt want it to my worst enemy
I mean sure, you're mocking the code for taking ages longer to write. But then in other videos you'll talk about how you don't like functions spanning more than four lines because of "locality of code" or something. Well the thing about a haskell function is that you get that exact locality because its way more simple to simply put 100 lines of code in one file, but not really so much for 1000-2000 lines of code--which for a tool like a json parser I can believe haskell would have so much more brevity.
Sure, it might be more difficult to understand how things are working under the hood because basically every single thing under the hood is a function call curried together. There is way more info in that 100 lines of code, which is why the more procedural approach (C) is going to be way more lines, but I would expect C code to generally compile to many more statements than it consisted of before it was compiled (although, maybe if the optimization is way better than I think I could see how it could be less). Either way, the idea is to try and simplify the instructions to us.
Computer code is the attempt to command an inanimate object to do something you want it to do. I think some times we forget that the code we write isn't just for the machines but also for ourselves. I'm not using haskell now, and I wouldn't use it for large team projects where I suspect lots of other people will be working with it. But I will definitely use it for my personal projects because I'm the best one who understands how I think about the code that I'm writing for my future self to be able to come back and understand how I made that inanimate thing do what I wanted it to do.
Its a great language, but because you're packing so much information into such a little space, its kinda difficult to work with other people in it. The nicest thing about trying to learn more about haskell was the discouragement they all give when you're having a problem: "what you don't understand that?" and I should respond OF COURSE I DIDN'T WRITE IT!
You got to remember who your audience is sometimes.
One of my favorite TH-cam programers (tsosen) moved from hasskle to c.
The guy makes really high quality stuff u would never guess he used to write hasskle
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
Haskell is useful to look nice on paper/in papers
top-to-bottom easy-to-read are actually words used for functional programming in my world lol
Look Prime, I don't mind you fiddling with the mic but BY GOD put some oil on that boom arm.
"No truck with" is Tom Sawyer/Mark Twain level old. The only reason I know this is because I read the unabridged version.
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.
Haskell became too mainstream nowadays.
"simple procedural C-like code, that's easy to read, top to bottom, in and out, easy... easy"
until you realize that you're keeping on debugging and fixing of a mid grade software for years, and it's your reality of a "new normal"
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..
I like functional better than object-oriented. I'd prefer procedural sure, but I think functional is an improvement.
Wired may not be the best source on programming languages. And "bloat" meant something different in 1977 than it does today. Emacs was considered "bloaty" back in the 80s. Rust's big failing is its borrow checker, and I spent most of my time trying to satisfy that vs. work on the problem at hand. Now, I do Haskell. And I like it.
What’s the Army of Darkness of programming languages?
John Backus reference is why you get a like on this video. The second reason is the Perl joke 🤣
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.
Sounds like this Haskell thing has the "Forth Curse".