Prime Reacts To Professor Reacting To Prime Reacting To FP | Prime Reacts 

frfr lmao

is not AI we need to fear. is this loop that just started

let's have Dave react to this video instead then the professor reacts to that video and prime reacts to that other video and....

It would be very topical to functional programming to have this kind of recursion

Yes, let's exclude that old guy who thinks he is wise somehow.

came here to say this, I was the asssistant professor at the university and I was told to explicitly make sure when I am quoting something or referring something, not to state that it is in any way controversial, including being funny!

Not if this gets tail call optimized

Closed, opinion based

Your stack is too small? Expand it in 3 days with our ULTIMATE STACK RESIZING UTILITY!!!

@@Daniel_Zhu_a6f Just download more stack!

@@Rastafa469 this one knows about functional programming

Now all that's left is to explain it in reaction video :D

Do you by chance have some examples I could google? Or on your channel? (careful sending links in comments, the algorithm sometimes picks that up as spam) I'm having a hard time seeing why one perspective will be better or worse than another, even in a specific situation. It feels like that's more of a skill/architectural issue than it is a perspective issue. We each naturally will "feel" like OOP or FP are going to be harder to debug, maintain, or add to later. But is that feeling real (and something we can identify) or is that just us being more comfortable with one perspective over another? Is it that we just often implement the perspective poorly, or that a perspective is 'actually' poor? I can imagine, as Prime pointed out, someone who doesn't look at things through FP (like him) and doesn't really understand FP (like he said he doesn't) would implement FP very badly, and have a hard time maintaining FP code as they can't see the perspective themselves. Much like I still don't really get OOP. The only instance I can think of where pure FP is probably bad, is when data is going to get changed many times by being passed between functions. Like in neural networks, where you might pass billions of data points through functionA, then to functionB, back to functionA, millions of times. Copying that data to not mutate the state would be both memory and compute intensive for no real bug/safety benefit.

@@connorskudlarek8598 I agree with that.

@@connorskudlarek8598 One good example where I find leaning more toward OOP is useful is game development, where there can be a lot of complex processes going on at a time, and objects make conceptual sense as references to entities in the game, that can each have their own actions and state. On the opposite end of the spectrum where I find functional programming a good fit, is data processing pipelines. You receive data is input, you run various computations on it, and you spit out an output. You don't want to spin up various instances of objects, you just want to process data. Procedural programming I find works well for most things in between, especially when working with typical applications where it's a lot of handling user input and rendering UI to a screen. You can of course use any of these paradigms for any of these scenarios, but they each have various niceties that make working in these particular scenarios significantly easier, in particular if you omit any sort of bias you may have from prior knowledge and experience. In the end, use what every you are most proficient in that can get the job done, unless you're trying to learn something else.

To me the real issue is abstraction not OOP or FP. What is really fun is that the basic concept of programming is abstraction. Programming languages are an abstraction on assembly which itself is an abstraction on electrical signals. The issue is having good abstractions, this is interface, or API. Building a good abstraction is incredibly hard, look at any small open source project with multiple developpers and insane amount of feedback arguing about what interfaces should be available. Whether a good abstraction you are using is OOP or FP doesn't matter at all, it is abstracted. To me, your project's architecture needs to be a really good set of abstractions. It requires time and thought to plan out and the sole purpose of that is to write the least abstractions possible on a daily basis because they are so hard. To take a simple example to me MVC is a model for abstraction that can be OOP or FP. Abstract the architecture and then when writing your models or your views or your controllers just go full procedural, your utils will almost necessarily be FP to be useful, your libraries will be one or the other and it really doesn't matter much as long as they work and have a great interface.

and how to get into functional?with realistic use cases i used OO only for orms but realised sql.exec() or query() is way easier and saves way less boilerplate....| i can understand functional but dont usually use higher order functions/lambdas can i have some good way to learn it OO is generally easier to learn not because of its inherent ease but the resources available to learn it compared to functional, i like the idea of functional(similar to math) but dont know how to use it.

@@rando521 in my opinion the best way to learn FP is to learn Haskell, since it _forces_ you to use a pure functional style. now, how do you learn haskell? there are plenty of resources available, both free and paid books, youtube video series, video lectures, etc. and of course don't forget to actually try to write code with it. I have also found it very helpful to read existing code and trying to figure out how it works. in the documentation for any haskell library, there will always be links to the corresponding piece of source code.

​@@asdfghyterElm is also an interesting purely functional language

So much React. React is everywhere.

The loop is closed.

Not to mention, Inner prime is watching Continuous Delivery at 1.5x - 2x speed; Inner Prime's video is 57 minutes long; and Outer Prime's video is just shy of 15 minutes

imma about to transfer to your school fr fr, this was so funny

Why not learn and then watch mindless BS to cool off.

And then I spend my time reading your reaction to a reaction of a reaction to a reaction to the worlds most terrible paradigm.

Painfully relatable

Your brain needs time to cool down in between sprints. Enjoy the madness

obviously those videos are only funny if you already know all the concepts

The overlap between Asmongold viewers and ThePrimeagen viewers is surprisingly high!

@@NostraDavid2 The overlap between an MMO streamer and a programming streamer is surprising?

Lmao this was my first thought, love a 4D abstraction reaction.

@@NostraDavid2Oh no… Im one of them 😂

Amen

flat_map!(Primeagen(Prof(Primagen(FP_Guy))))

Wtf I literally just left a comment on this vid saying is it just me or does anyone else feel like prime's a big bill burr fan😂scrolled down to see this

@PisterLabs did in comment form

Anyone programming in modern times with anything other than assembly subscribes to a ton of constraints. Say, structured programming, ie, not using goto, but function calls instead, is a constraint. You using objects is a constraint. It's a constrained way of structuring data/code. The interesting bit is that it is somewhat opposed to functional school of structuring data/code, but you can do both constraints, tho synergy isn't on your side there.

@@gJonii I meant more specifically the mutability/immutability constraints that tend to go with functional programming, the disavowal of raw pointers, that kind of thing. I agree that procedural has constraints, just different ones than the kind that functional programmers tend to adopt. And even within procedural schools, people disagree. Rust people don't do raw pointers. C people don't mind them.

Tbh in order for a language to be truly functional it has to be lazy in its design. When you're sticking to hardcore immutability where in place modifications are a huge taboo, you're naturally forced to use linked lists or other immutable recursive data structures like Trees and processing those immutable recursive structures in a lazy context is much more effecient than strict context. Recursion in general becomes flexibly natural in a lazy context. But of course that doesn't necessarily mean it's also very efficient to do so. If you had to choose between strict + imutability vs lazy + immutability, lazy + immutability wins but if it was strict + mutability vs lazy + immutability, strict + mutability easily wins over them all (at least in terms of memory efficiency most of the time).

@@tedbendixson I guess that makes my code a combination of the two. Because its entirely possible to mix and match parts of your code with different styles, and sometimes it makes more sense - at least to me. I generally allow myself to figure out the structure of how I want to do something by messing around, then scrap it all and design something good from the start based on what I learned... when you have a second chance you can come up with all sorts of ways to optimize and make your code cleaner, more efficient, & more reusable, things you just wouldn't think of the first time without a better perspective of the problem.

​@@samuraijosh1595immutability doesn't require a certain evaluation strategy. Also, you can use arrays in immutable languages, so long as each element is only assigned a value once.

I'll try my best

At some point they will become confused and react to themselves.

It's not academia that's pushing OOP. True Computer science academia is actually still on the functional bro ride. These universities have rolled out courses where they supposedly teach "industry -useful" languages and design patterns and what's their bright idea of "industry-useful" skills? Yeah it's fucking OOP again. This is a never-ending mindless cycle.

It's so easy to buy in to OOP and inheritance. I wish the industry wasn't so dogmatic about it. And I wish that there were less gatekeepers among those who are proficient in both hardware understanding and procedural code.

This is the realest take I've seen. Of the 4 computer science university courses I've taken, they all circle back to "OOP is the holy grail that will solve all your problems."??? Universities are psyops by the secret society of OOP to convince the population that there are no other paradigms.

Academia is also responsible for selling the idea that functional programming is as easy to learn as its procedural counterpart whilst also maintaining an extremely high bar for entry. Haskell is 33 years old and there's not a single person in that community that's capable of explaining monads in a way that doesn't require you to already know what they are or have knowledge of category theory. The same goes for many of the complex parts of C++, Rust and so on. It's almost like people are in a pissing context to see who can craft the most complex solution just so they can bask about how smart they are.

@@BrunodeSouzaLino you're making a strawman.

You KNOW the professor is here watching

whatever it is, it's about to become a mandela

"hard to consume" 🤢