It always has been.

@@ThePrimeTimeagen PP 🧑‍🚀 🔫 👨‍🚀

​@@ThePrimeTimeagen All bow to the might PP. 🍆

You knew what you were going to do when you were typing that.

There is nothing wrong with liking PP.

Honestly, that is why i do not like devs that shill OOP as the best thing in the world. They just know how to copy and paste stuff they have seen in books, like "Clean Code™", and love to overcomplicate everything because it is a "Good design pattern". Getters and setters are perfect examples, they are useless in 90% of ocasions, but OOP shillers use them everywhere, even though it does the same thing as just acessing the variable directly.

@@rj7250a it's not even good OOP in my view, it just adds noise. If you evaluate your objects by asking "what should each field/method be able to do" and not just add things because it's what you've been told, you wind up with OOP code that actually takes advantage of encapsulation instead of doing backflips to get around it. So for example, if you have a field with a get/set that just returns/sets the underlying property and NOTHING else... why wouldn't that just be a public field on the object? It's adding lines to just add lines, lol.

Setter- and Getter function are kind of a mess if you ask me. If changing or reading a Class property has to lead to a chain reaction, then they are mostly unavoidable. But, if the property is independed then having to define 2 extra methods just for the user to access them, bloats the Classes code. Its kind of a trade: For a Class user, knowing that changes to an object can only be done via methods is easier to understand. (hence why everyon thinks it is "Cleaner") But for the Class writer, it mostly boats the code and makes things harder to read/navigate. That is, why i love Javascripts 'get' and 'set' function attributes and PHPs __GET and __SET Magic Functions. They let you do all the stuff, that Setter and Getter functions can do, but still present them both combined just as one attribute to the Class User.

There are some usecases : - the user should only get or set the value - you need to do data validation before setting the value In this example it makes no sense

@@zacharychristy8928 I have seen good OOP, but it has been done by pragmatic programers, not OOP shillers. Pragmatic programmers use whatever is the best for the current problem, they do not follow a strict set of principles in a book, as if it was a religious dogma.

Go read any lisp book ever written. I will bet a million dollars chapter one describes how s-expressions work.

What's wrong with describing it like thaf?

@@Cookiekeks Everyone does that. At this point, it is either just filler if you know what OOP and PF is, or a video for beginners, which you can find an abundance here.

It always brings me pain, because they (almost) always give class examples of real-world objects. Code is not real life, classificiation is never that simple and clear in practice. I'm not writing code to deal with the different types of apples or fish. I'm handling files, or graphics, or compression, or strings.

@@colemanroberts1102 the emacs lisp book chapter one describes how to read the book; chapter 2 (the first real chapter) describes the data types in fact it says nothing about how the program is evaluated before chapter 10, and the term `s-expression' does not appear (outside of footnotes) before chapter 35 out of 42

Hold on we accept input... hold on the computer accepts power and moves the computer into another world where input has been received. 😂😂😂😂😂😂

Finally a language to surpass Haskell

You cant say that. A mature response is not for the internet! Here you need to pour gas on the fire and say "THIS PARADIGM IS TRASH, THE ONE I LIKE IS BETTER!!!!". Dont be sensible. It's the internet.

can you please elaborate on declarative and imperative code ? is my thinking correct that all declarative code is always abstracting some underlying imperative logic? To me the functional paradigm seems declarative in a way that it abstracts imperative logic. for e.g even when writing an 'imperative' c = a + b, we are abstracting the logic of actual addition on bits away from us in the "+" operator, in turn making it declarative. Also if you've used react can you comment what kind of paradigm its following? is it functional UI or declarative JSX? or something else? I think its time for me to learn haskell lol

I remember once... in haskell I was trying to manage "connection codes" on a server... kinda "low level" in the sense I only used the standard libraries to do it... no frameworks... You start client A, which asks to connect... The server accepts and sends a "code"... You could(out of the loop) send to your friend... Your friend starts client B which send that same code to the server... and then you( and your friend) start a session(in my case... a battleship game) managed by the server in particular... to manage the codes in a server... I essentially needed 2 functionalities: 1. Create a brand new code associated with connection with client A(which just connected asking to make a new connection)... give out the code(so the server transmits to the client A so you can send to your friend) 2. Given a code... return the connection you and your friend can play; I'm not using the haskell notation like I did there. I will do the equivalent in python; def codeManager(): id = 0 connections_to_be_paired = dict() def assignID(connection : TCPConnection): nonlocal id current_id = id id += 1 connections_to_be_paired[current_id] = connection return current_id def pairConnection(pairing_id): try: connection = connections_to_be_paired[pairing_id] del connections_to_be_paired[pairing_id] return value except: return None# This function originally returned Option.... so it was not as sketchy as it is in python return (assignID,pairConnection) That's like.... very old school OO done via closures. People would use a class for this, with attributes "id" and "connections_to_be_paired" private(here they are encapsulated because there's no way to reach them from outside), and public methods "assignID" and "pairConnection" (in my bodge they are the return values). It's not bad... but you had to remember the order of the "methods" that were returned: assignID, pairConnection = codeManager() # assignID, pairConnection... just like the function returns Nowadays I would have wrapped them in a struct equivalent in haskell. The closest thing to class you can get without significantly more workarounds

Woah woah, don't be writing Python out of nowhere like that! There are children around here!

@@zyriab5797 do you really want it in haskell?

Nice idea, I'll try next time and give my result ^^

This made me laugh more than it should've.

i love you

Disgusting

I can handle 2 or 4. I tolerate 8. But I've seen 1 space indenting and I wanted to curl into the fetal position and cry. With 3, you are just pissing off anyone with OCD, lol.

Be careful though, as Prime noted in one of his previous video, this approach of incremental fixing toward some local optimum may lead you to find out that it needs a complete rewrite to get the best global optimum solution. However, in my opinion, following paradigms like FP or OOP, or maybe even some custom ruleset, can allow you to get to those local optima quicker, as you train yourself to write paradigm-following code more and more, thus saving you time on incremental fixing in the long run. I think this is also literally the point of Rust, which always seems hard and slow to write, but in the long run you would not only write more correct code first try, but also know writing what could get you more correct.

​​@@CYXXYC The more sure the requirements are, the closer it gets to that last step. Unfortunately, an ever evolving product with even more unsure product folks keep me from going past step 3 most of the time anyway.

@@SimGunther Hi can you please suggest me some program/system I could write to test different paradigms and even custom rulesets for their tradeoffs and to also upskill myself in different modes of programming/designing systems. TIA

That’s pretty much just called “programming” and how it should always be done. 1) do exactly what you need to do with data. 2) abstract out the common state for compressed and efficient code.

that's a nice analysis

I remember encountering Basic when using a Commodore64 emulator, and found the goto keyword to be really cool and simple. I still kinda miss using it. Goto is just really simple and easy to understand! if condition, go here in this part of the code! if not, just continue on then perhaps when that not statement is done, jump to the end.

I mean this is how I program... But I avoid repeating the same code, so it becomes a separate function. And if something is clearly delineated from the rest then I also move it into a separate function. The resulting code is more performant, readable, and maintainable than what you get with OOP.

@@etodemerzel2627 yes, the most common pattern unfortunately is called the big ball of mud. I used to write like that back in the day before getting into clean code, architecture and design patterns.

@@farqueueman Well, I'm moving away from Clean Code:tm:, etc. Over the years, I've seen plenty of codebases written with these approaches. All of these codebases are awful: hard to read and navigate, hard to change anything, and, on top of that, they're slow. My "ball of mud" is better in every way.

@@etodemerzel2627 lol

DEZIGN BATTERN YAS

A Django app was my first large production OOP based thing to work on. It's awful. As you go into things to figure out what's going on it just goes everywhere.

"the scope only gets tighter and tighter." This is kinda the essence of composition in OOP. However it's not that simple, it's usually almost impossible to design code in purely hierarchical manner. Now OOP has produced plenty of great literature how to design your application that can achieve this property - onion/hexagonal/etc architectures are all born from applying the principle of composition to large apps.

@@sk-sm9sh Pure functional is all about composition because there's no way not to do it! Tons of purely hieracrchical projects exist using Elm or Haskell since they don't allow using something you don't pass in (with some tiny exceptions!). You should try out some FP languages if you're curious!

@@TankorSmash here we go again "you should try some FP". From my experience really more people tried it that FP zealots like to think. Just because I tried it doesn't mean I love it already. To me it falls short in many regards.

@@sk-sm9sh You're saying you tried one of them and didn't like it? That's totally valid too! There's unfortunately no silver bullet after all.

Common Lisp is best lisp. Scheme is so small that tons of important functionality is implementation dependent. Common lisp has a big standard, but excellent facilities. Also, unhygienic macros, unwind-protect, CLOS, excellent exception handling, optional dynamic scoping, etc. Clojure has neat features and excellent java interop, and scheme is super small and really lets the implementor play around the design space. But common lisp's interactive development is top tier, even among lisp's.

Also if your compiler/interpreter cannot collapse several chained map functions into a single loop it is not really functional programming. It is just functional style. Take SQL for example, you can nest SELECT clauses all you want, but it isn't going to create a bunch of temporary tables if it can evaluate the expression with one index traversal. SQL in that regard is much more functional than the functional part of JavaScript. Of course in SQL you can't store functions as values in tables, so that is where that ends.

​@@colemanroberts1102 Common Lisp definitely is more suitable for making relatively fast real-world applications, but for someone more interested in learning programming language paradigms & fundamentals, Scheme's minimalism & simplicity is actually a benefit, e.g. I couldn't wrap my head around the concept of an "object" until I had to implement them from scratch in Scheme as a CS freshman. Other things we implemented in it are a type system (using cons cells), lazy evaluation (using lambdas), DSLs, a filesystem, a relational database management system, a meta-circular evaluator, and just about every data structure known to mankind. It's the ideal teaching language imo. Also, Racket is a great scheme variant that offers the best of both, with a comprehensive standard library, package manager, build tool, and top-notch documentation, it even comes with its own IDE, the only thing it really lacks is speed.

@@ultru3525 minus the meta-circular evaluator, all those things are just as easily done using the same techniques in Common Lisp. You are correct about scheme being a better platform for learning to implement a language though.

​@@colemanroberts1102 Oh yeah, I wasn't trying to imply you can't do those in Common Lisp, my point was that all of those can be done in Scheme, in spite of its limited facilities. And as a teaching language, I feel like Common Lisp suffers from the same problem as Java: too many options that are useful in production, but can only serve as a distraction when you're trying to focus on the fundamentals. Common Lisp was the second language I got comfortable with after Python, and while spending two days trying out all permutations of `loop` keywords was interesting, it wasn't really the best use of my time. With Scheme, it's practically impossible to "waste" time learning language-specific features, you'd have to delve deep into the intricacies of continuations for that.

Unfortunately true.

Not it's not. It just means abstract methods as in eg interfaces.

LFG!

This is basically the raison d'être of Erlang (and by extension Elixir), it's astonishing how seamless & lightweight process creation is. I'm not aware of any other language where you can be running thousands of threads without even batting an eye.

@@ultru3525 Unison would be another one.

oop has a problem. creates redundant elements in memory. In many programming languages an object inherits from a base object. Therefore, every time it is instantiated, its elements, properties, methods, special methods, etc. are also loaded. fp doesn't do that. The data is separated from the methods, whether they are pure functions (calculation) or impure functions of actions. In addition, the Earlang virtual machine does one thing, and that is the virtualization of processes, so these are not loaded into the operating system with a life cycle and everything else, they are done within a virtual manager of processes and their Manager and process hierarchical trees

Mutable data doesn't scare this man

Correct. Haskell manages those effects.

OOP maps well to the real world?! We must be living in different worlds then.

@@etodemerzel2627 ehhhh...? I know you can create custom types and there is the data keyword in Haskell but... I don't use it... maybe that's the world I'm from.

@@etodemerzel2627 On the fundamental level the living world around us is a bunch of cells communicating. Like a bunch of "objects" passing "messages".

@@freesoftwareextremist8119 That's true OOP or Actor model as it's known these days.

It’s a grave error to try and map the “real world” to code. Code exists entirely in 0’s and 1’s. There is no “chair” that inherits from “furniture”. There is only data.

I am learning DOP now, but is only popular between game devs now, since it uses very unconventional syntax and is harder to extend. I have seen languages like Zig, that are trying to make DOP more ergonomic, you can write a conventional struct, then use a function from the stdlib, so it will be converted to a data oriented pattern under the hood.

@@rj7250a any resources you have for DOP ? thanks!

generics too ffs

> Also, OO people talk about data hiding What people talk by data hiding is exactly what you mention later - hiding internal representation, thus establishing encapsulation. Nobody has ever said that you should not have methods that return values.

Implicit rules are ok if your team is small. How you're going to enforce it if there is 100+ people working on project? Java has so many access control keywords for large teams and indeed they are unnecessary for small teams but for large organizations being able to specify access-control is very helpful as it's makes enforcing ownership easier. For instance I tell that I own this class, and I put everything as private. Now it is easily guaranteed that no one will access the private vars without modifying the file. Since I observe changes to my file I can easily notice if someone tries to get stuff that I marked as private.

@@sk-sm9sh Having 100+ people working on a single codebase is becoming pretty rare these days. I only work on two types of projects right now - personal projects with one developer, or micro services with 1-3 developers. But, hypothetically, if you have more developers, you don’t want them checking in code that hasn’t been reviewed by at least one senior developer. At that point, it would be their job to ensure that the code is in the right file, and that it either has zero dependencies, or that it only references code that is located in its sub-domain. Think of it as an org chart. If everything is organized properly, you don’t normally have salespeople talking directly to developers. Technically, you can, and it’s not really the end of the world if it happens. But ideally, you want that information to go through some sort of management structure, so that resources can be prioritized properly. I essentially do the same thing with software architecture. I have components that actually do work (read files, send messages, query data, etc.) but make no decisions, and I have “management” components that wait for event notifications from sub-components, and then send commands to other sub-components. I also try to keep the number of sub-components managed by a single management component to a minimum, usually no more than 2. This makes design work fairly trivial, and when something doesn’t work properly, it’s pretty obvious where the problem is. Although I’d have to say that this approach really does make things so simple that code often works as expected on the very first try.

Sounds terrible lol

@@sk-sm9sh Thanks!

Overall, I do agree, but maybe I’m just…not a developer? (I worked as a dev in the past, though) You see, for me, classes of equivalence matter a lot. So to keep track of that, you must follow stricter rules. Pure functions definitely help with that! Too much perfectionism..sorry. I don’t like (regular) dev work. Waay to much mambo-jumbo and spaghetti.. I’m more conceptual..😢 I suffer..

​ @simoninkin9090 , I think I'm saying that, but with more mumbo-jumbo. I'm pointing out that there are some real considerations, but if all you care about is being able to put a name followed by a dot, and have your IDE suggest completions, you can do that in either paradigm, not just by using classes.

@@samhughes1747 I totally agree about the necessity of good namespacing. The question is ultimately about composition. Sure, objects can also compose (I did some of that a few times), but then these objects must comply with the similar rules as pure functions. And it is actually harder to work with.. you might want to call these “function objects”. There is an override in cpp for such cases. You can definitely do everything in either paradigm. In fact, as a _professional_ (the one I do not ever want to become…because screw the payoff! =)) ) you should be able to slide though the codebase, written by other people and follow the paradigms in the code itself. All significant modifications must be accepted by the tech lead, etc.. What I’m talking about is kinda R&D…or whatever. Maybe it’s not that practical in real life (though, the finished code can be optimized and quite fast..just that nobody would understand it..that’s all..), but I honestly don’t care. There is no freedom in commercial programming. For some people it’s..well - just a job. (Don’t get me wrong though, I’m quite average). Yet, for me, it’s more like a tool for understanding deeper realms of our universe. Not freakin’ kidding! =))) FP maps very well onto many concepts in modern physics (I’m not a physicist, but I’m really curious and can’t stop digging for answers..or rather - more questions) P.s. never actually touched Rust myself, but the iterator pattern sounds like it’s the same as STL iterators. In fact, the essence of C++, the Standard Template Library is also functional! But it’s a mess! If you compare that even to F# (hate dotnet though..or any vm, which is not llvm. Bytecode really sucks!) or even better - Elixir (possibly the cleanest syntax I’ve seen in a programming language)

@@simoninkin9090, gotcha. I was mostly complaining about the idea of dismissing FP based on auto-completion advantages, and emphasizing that OOP and FP both have namespaces that lend to that auto-completion. It’s one of the most common complaints about FP I hear, and it’s nonsense. Meanwhile, yeah, I work on a team with a variety of skill and discipline levels. We have a lot of code that drags a logger of some kind through the whole program, and same for whatever database or API client is being used. It’s nauseating, but I’d the program does what it’s supposed to, and if there’s tests to PROVE that pile of tech-debt does what it’s supposed to, I’ll sign off. I care far more about my coworkers doing good failure-mode analysis and proper error-handling. My team lead will back me up on complaints about squashed errors or untyped interfaces, but he isn’t going to back me up on holding work hostage to a paradigm that is generally widely misunderstood. I absolutely am convinced by the ideals of the FP paradigm. In practice, like you say, there’s everyone you work with, and you’re writing code for them to read too.

REACTIVE + DECLARATIVE (language oriented) is best

ai won't replace plumbers yet lol so it's a good idea to switch

@@ichbinhier355 yup

People mostly use Information Hiding not to hide information, but to hide the the gross stuff they built when no-one was looking.

hah, oh no

Straight talk oop tries to force someone to accurately predict the future, something humans are actively bad at. Also makes refactors hard and reasoning about challenging. One needs the entire inerhitance tree to figure things out.

​@@thegrumpydeveloper maybe you've never seen OOP done well. Outside inheritance which is horrible, OOP often works fine.

@@NathanHedglin At this point, "OOP done well" is just a legend.

You might want to see the Unison language. You basically get versioned classes for free

I’ve seen oop done horribly wrong so many times. The paradigm leads people to the wrong abstractions more often than not which to me is a bad design. People get a hammer and try to turn everything into a nail (see my oo there?). Even if done well, it’s a single layer inheritance which would be better suited to interface/trait based coding or better and cleaner apis.

True, but you don't have to write functional code like that.

Clever code is the worst paradigm, regardless of code practices

Terse code - yes* Clever hacks - absolutely not! In purely functional languages we strive hard to never leak any implementation details and to make all behavior fully defined. This means hacks should just never be possible. Ideally, the types would specify all properties of your code, so that it wouldn't matter if the implementation itself is ugly (not that functional programmers would want to write ugly code). Then the correctness can be proven and verified automatically. * definitions typically one line long, staying on just _one_ abstraction level

Ehhh... What's happening is like when you learn another language go to their country and you hear a native speak in all slangs. That's the FP community online they know other FP like minded people will understand so they don't bother speaking formally

- So you prefer verbose code - stupid repetitive code Sounds like Golang