I think OOP is what completely drove programming off a cliff. In the end, everyone says OOP exists either for code resuability or maintainability. I can address both of them with stateful functions: Code can only be reused because there's reusable blocks of code. And functions are nothing but blocks of code. Meaningful names to functions and their parameters, while ensuring these functions are as generic as possible, can make the whole project maintainable. While some say OOP also offers data security like data hiding and behavior abstraction, I find it extremely stupid. Why are we even worrying about whether some code outside a class will mess with it? That's because we are relying too much on a single shared state. Rather, every function should have its own state. I like to call them stateful functions. This will allow us to actually get all the features of OOP while offering better security and maintainability, while not impacting performance(sure the memory footprint might be a little larger, but that can be avoided using some kind of RAII techniques to clean up unused state)
Until the container software is slow, too resource intensive, networking is a pain, communication between containers is a pain, it's not modular, it's not easily editable or modifiable and just plain doesn't work. docker fs sync is shit slow on windows for instance and also has specific requirements compared to linux/mac. The whole registry thing is jank as hell when using custom registries
that chuckle at the outro line was gold! thank you for the video, I've been agonizing over my first coding project and I think I'll try again with this as a reference :)
I find functional programming very interesting and I've been trying reallyhard to use it whenever is possible, unfortunately as a game developer pure functional is useless to me, as immutability generates more problems than it solves, and objects are very handy for so many things
Yeah it's more useful in systems messaging and finance situations. Games are very dymanic and don't lend as well to functional, though many of the concepts are transferrable in the forms of data structs
@@coderized yep, the only functional language I know is f#, and I try to use it everywhere I can (thanks to the .not compatibility), which is way less often then I'd like, but still better than nothing
@@coderized yep, the only functional language I know is f#, and I try to use it everywhere I can (thanks to the .not compatibility), which is way less often then I'd like, but still better than nothing
I've been learning CS for 2 weeks now, which means that I probably didn't understand much of this video. But I sensed that it was clear and important. Saved it for later. Animation is amazing!
how does this have 81k likes, what a terrible video i understood nothing and ur voice made me rewind atleast 5 times because i cant understand the words ur saying
no wonder the name functional paradigm seemed familiar, we did go through that during our OOP lectures, and funnily enough i asked the teacher if we can use oop alongside procedural and that's when i gt to know that in modern development a mix of all oop, procedural and functional is used. And we used c# for all those things
Interestingly none of this is present in 99.99999% of all opensource modules and tools that you all use and trust. programming is becoming a cult, and we are approaching the time of the inquisition.
I'm a self taught developer. I mist learn these things. Please suggest me a book. Also please tell me what softwares do you use to create this video? Thank you so much in advance!!
Because the “implementation failure” class of bugs (the most dangerous I’d argue) is eliminated. For example in java you could have a data structure represented by an array, but that array has to have a specific format or it will be meaningless and crash other functions that deal with that structure (unless they all constantly check which is wasteful). Later, let’s say you accidentally create a function that can rarely produce an invalid array. Now your program crashes. Even though you defined those other functions to “do THIS to THAT”, that wasn’t guaranteed at all. In a language like Haskell, this is not possible. You would define the structure and make it a type such that every function that works with it is guaranteed to receive or produce a valid one. These languages generally make it *impossible* for something to not be as you previously defined it. Also since you do definitions not implementation, things so exactly what they say. With non-fp you have to keep track of both your definitions AND how you implemented them, since those two things are not always the same in non-FP. Anyway there are bugs in fp such as “I defined it wrong” but even that’s much harder since the typing and consistency of functions makes it so that accidentally producing the wrong structure is very hard
It seems like FP is the panacea... it's even stated that it's more readable at 7:57 Well, instead of nice exceptions as you find in Python for example, in FP you have to implement early return/abort using a monad, and that's not "more readable" in my book.
I really appreciate how this video describes concrete steps and characteristics of modular & decoupled code instead of paying lip service to the ideas like most things ive seen online do.
