Why is OOP bad?

people who wreck systems
people who destroy decent people, work
frick their 'jubilee'
they are failed animals
worthless cowards
soldiers suicidign over afghanistan?
they should t he worthless shit.
try doing a reaal job
try doing it for those animals
waste your fricking time
british are vermin

some IDIOT way back. is on youtube was selling 'programming in python without objects'

can only say that you've got tricked

he presents everything in a well presented manner, but basically the whole video is based on strawman arguments
he builds overly abstract and convoluted examples that would make no sense as soon as you tried to write a real example of such a program structure, at the same time not even giving a good definition what "abstraction" is

I've always considered this the best anti-OOP lecture, because it is explicitly anti-OOP just anti-bad design.

>when it isn't misused it's useless.
wrong

public class Animal
{
public string Name {get; set; }
public int Age {get; set; }
}

public class Dog : Animal
{
//all fields of animal are here ez pz
}

That's one way of doing things, mine is less abstract.

a dog is an animal, ok. But at the same time a dog can also be a family member, which isn't an animal. Or a dog could be an asset. Inheritance is just terrible at modeling the world, the world isn't hierarchical

Multiple inheritance is not a good thing. It makes it just worse.
Use composition instead

Yes. This design is way more flexible than any inheritance based approach.

>[Dog] is a family member
Are you moronic? You don't implement it that way. You literally solved your problem in your sentence. "Dog is a family member" means "Dog is a member of family" which is the same as "Family has a dog" so an object of type Family should contain Dogs and Humans.

>dog can also be a family member, which isn't an animal
No shit. That's why you create a FamilyMember interface so that you can choose which Animals are capable of being family members and doing actions like love(), hug(), molest(), or whatever the frick. An abstract Animal or a subclass Mammal won't necessarily be family members so they won't implement the FamilyMember interface, but Dog and Human can be family members so those classes will implement the interface. The Family class should be made so that it can only contain objects that implement the FamilyMember interface.

This is pretty fricking simple and super easy to scale as you add more animals, and not just animals. Say you're one of those families that consider their Roomba to be a family member. All Roombas are robots, so Roomba will extend abstract Robot and get robot's methods. But, Roomba will implement FamilyMember so Family thehomosexuals will be perfectly satisfied having a Roomba among its ranks.

>As soon as a function takes two different objects, it already shows the shortcomings of putting them inside objects
I take it you have problems with human language grammar too?

You can literally do it in most oop languages it is just pointless

I find that data as code just causes problems. For example, internal fields are like phantom parameters to all of the methods in the object, and it is easy for the programmer to forget that the method must also be complete in regards to these parameters.
Much less problems arise when you just separate the code from the data. Store data in structs and records and pass them through static functions. Essentially instead of "thing.action()" you do "action(thing)". This alone improves the stability and readability of the code significantly.

Does not solve the problem you had

>internal fields are phantom parameters
If you have direct access to them, then it is much easier to frick things up

For instance if a field is a pointer and whenever you set it to something else you want it to be deleted. You add some setter method that releases the resources first. This is bad because it hides the invincible parameter, apparently. However if you manually have to release it, and the field is referenced 99 times in the code, good luck finding the memory leak

Not having access to fields make correctness easier to achieve, not harder

Also, classes are rarely data. Sometimes they are, when you are representing sql for instance, but usually they are separated concerns and their state exists so they can do their job. This is why I hate the college example of classes because 99% percent of the time your class is some sort of manager or helper, that imports files or generates output, not data. It is much simpler to manage your program as if it were boxes of lego separated by color and function, meanwhile some people just want one big box of lego tht has everything dumped together since “looking into boxes is annoying”

you know what leads into what
you know what becomes what
you know what generates what
if you can't remember to that scale
forget programming
cos you forget

legacy companies aren't junk stock
shitheaps

microsoft
facebook
twitter

prime stocks
your economy is nothing
why the $ is no longer the reserve currency
you are fricking idiots
now

the only stock is amazon

putin will do it

show me a non-trivial program written in functional style which is not compositional?
even seemingly imperative let-bindings are disguised function composition.
let x = f p in g x

is equivalent to
(x -> g x) (f p)

It was 1 guy years ago who wrote all the F# stuff and pushed it heavily. Way before my time. Im guessing nobody else was onboard with F#. He also made the borderline insane Winforms code the company was using.

you got filtered
imperative programming should never have been invented in the first place, that way we would have kept brainlets and pajeets out

Filtered and happy 🙂

quickly reading up the definitions on wikipedia, no, it's not - the interface polymorphism comes from the other direction than what's described as "ad hoc polymorphism" (function/operator overloading)