Comments by "justanothercomment" (@justanothercomment416) on "You dont know OOP" video.

This is why objects which are likely to require this type of control should use getters/setters but most should not. If your base class requires this type of control, use them. If it does not, don't. Then if needed, create special cases in the derived. Which will likely only be used in the special case derived, likely implying it should be private anyways. Which means the special case may well be hidden within the specialized derived implementation. Which brings us full circle that for the vast majority of cases, getter/setters should be avoided unless it's a requirement of the base. Contrary to one of the of gallery comments, composition does not avoid some of these complexity or issues in any way. It simply changes the surface area where it does. I'm honestly shocked so many people lack such a fundamental background on OOP yet are willing to rally against it.
8
@krux02 That's odd, given that decades of develop completely invalidates your position. Just because you struggle with it doesn't mean everything external is a failure. It simply means you need to look within and determine why you've failed to succeed with it? Your failure is not everyone or everything else's. Owning our failures is an opportunity to grow.
3
@CigEconomy It's easy to write bad any kind of code. This is the default for most developers.
3
And the things they dislike about inheritance is inheritance done poorly. They then falsely claim all inheritance is bad because on the exception rather than the rule. It's simply not a well grounded position to argue. Is OOP perfect? Nope. Is composition perfect? Nope. Is functional perfect? Nope. So on and so on... Far too many carpenters are blaming their tools or refusing to look in a mirror.
3
@Prim-v1d Exactly. Some domains inherently lean into inheritance. Some into composition. Some into neither. The failure isn't OOP or composition or functional or whatever. It's the designer. The right tool is always the right tool. The trick is knowing when to use the right tool.
3
This is a ailure of your education. Do they not teach "is a" vs "has a"? "Is a", means inheritance. "Has a" means composition. You can use both at the same time. The complaints here about OOP is really a skill failure in understanding proper OOP design and engineering. For example, people often create a Car and then derive a Truck and then mandate a Car or a Truck also has wheels and transmission and an engine. Then try to create interfaces off of these abstractions. Never mind the abstraction is completely wrong from the beginning. Of course it all breaks. That's not OOP's failure. Composition and Inheritance are not mutually exclusive. They are extremely complimentary. The issue is, apparently, schools are no longer properly teaching the paradigms. A car "is a" vehicle. A truck "is a" vehicle. A vehicle "has a" motor. A vehicle "has a" transmission. A vehicle "has a" wheels. This well highlights the lines of abstraction and each associated interface to compliment each of those abstractions. Suddenly you're using both and the abstractions well identify the interfaces.
3
@Salantor That's a sign you over abstracted. That's a dev failure not an OOP failure.
2
@Salantor Yes. Let me guess, you walk everywhere you go.
2
@0oShwavyo0 Bingo. Imaginary corner cases are just that, imaginary and corner cases. Neither is cause to establish the rule. Exceptions are not the rule. Exceptions do not invalidate the rule. So strange how it seems to now be the norm that poor developers blame language features for their own failures.
2
Most every day cases where OOP fails is because of poor developers who don't actually understand the domain. Like any tool a developer is required to learn it. Far too many don't learn their tools.
2
@YaroslavFedevych The design by co mit ee is a big problem for Java and C# create examples of how not to do things. Once can create good designs having three or four layers but it should be questioned and resisted. If there are more than four I'd seriously question the entire basis of the abstraction. Cause exists at four too. Far too many people here blame the concept for what is plainly poor design/engineering.
2
@Ghorda9 Wild assumptions of the criteria and completely misses the mark of the comment's purpose.
2
@SimonBuchanNz I've written UI widgets before. Several times. There's not need for complications and OOP almost always fits well. Bad carpenters are bad carpenters. What you describe is a bad job of abstraction and inheritance. It does not in any imply inheritance is the issue. That said, maybe composition was a better fit for that specific developer? I dunno.
1
@SimonBuchanNz Why would you assume I've not worked with or created large frameworks? This issue here is the assumption that all UI frameworks fail at abstraction. This is a personal bias you're bringing into the discussion. What's funny here is so many young people are rushing to recreate all the failures which brought us to where we are today. Is OOP perfect? No. Nothing is. But having much success with very large OOP projects and frameworks in complex domains, and that I'm not alone, invalidates all the hubris that OOP has failed.
1
This is why you learn. Ignorance is never an excuse to avoid. It simply makes one ignorant.
1
@kobi665 I don't have a take on that. Am willing to agree. If they are not teaching the fundamentals of abstraction, interfaces, inheritance, composition, and the associated low level implications of each choice, then most anything which follows is taught to early. Both have advantages and disadvantages. The primary push for composition is specifically for performance for cache/memory locality. There certainly is something to be said for that. This push primarily originates from game programming. But it's found to have advantages anywhere large numbers of objects in memory is a requirement. Which potentially brings in "records." Likewise, there are some other advantages, yet the primary push did originate for games for performance. There's a time and place for both approaches. Yet premature optimization remains the root of all evil. Which means when people pick composition over inheritance simply because of a potentially imagined performance benefit, they are still juggling with folly. The truth is, most people understand the abstractions provided on inheritance better than other models. It's more or less how we are taught to relate to the world around us. That, however, doesn't mean abstractions can't be poor, too complex, too abstract, or just plain dumb. That's before the implementation even occurs. IMOHO, this is one of the greatest issues with languages like C# and especially Java, in that their libraries are frequently designed by committee, resulting in sheer idiocy of interface and abstraction. They are burdens rather than solutions. Sadly, far too many fight "best tool" logic, which includes best design and best abstraction. If your favorite tool is a hammer we always try to see the world through nails. Nothing wrong with nails. In many cases nails are excellent. But some jobs require screws. In many cases, screws are superior to nails. In some cases nails are required. Side note, nails and screws provide different failure modes and as such have specific requirements for use to avoid structural catastrophe. Our jobs is to understand nails, screws, and many other fasteners. And then apply them appropriately. /soapbox
1
@kobi665 Appears YT deleted my comment. They love to censor everything.
1
I agree. In the bulk of the cases, inheritance is excellent. They are seeking out the minority to false present it as the rule. It's an extremely dishonest basis to refute a position. Yet it seems very popular. Its popularity makes me wonder what has happened to the industry and what is wrong with so many would be developers.
1
@T1Oracle Given it benefits far more than it harms and it only harms given poor developers, it's difficult to justify removal.
1
You are correct. You can tell from the gallery most of the comments are plagued with inexperience.
1
@YaroslavFedevych You nailed it. I wrote a rather long reply along these very lines. YT deleted for whatever reason. You are completely correct.
1
@YaroslavFedevych Just replied to you supporting your position and youtube deleted it.
1
@YaroslavFedevych odd, seems that word is not allowed.
1