Object oriented programming in Python be like:
-
Wait there's a "that"???
wrote on last edited by [email protected]it's common practice as a workaround to save
thiswhen changing contexts, sincethismay change under you, in callbacks and such -
that's because anyone who develops oop in Python is mentally ill.
Python is a scripting language, not to be confused with an actual programming language. Like everything else in development over the last decade, newbs are just shoehorning whatever is hot into the language because nobody is stopping them.
You're right in that OOP feels very shoehorned in with Python. But not every project has a Linus Torvalds to publicly humiliate horrible ideas and implementations.
-
Reminds me of java
I have
Toolkit toolkit = Toolkit.getDefaultToolkit();seared into my brain. Then there were the bean factories…At least with Rust, there is a specific, defensible goal for why it does that.
Java is just over designed. All of
java.ioreads like somebody's Object Orientated Programming 101 final project, and they'd get a B- for it. Lots of things where you can see how they're abstracting things, but there's no thought at all in bringing it together in a tidy way. -
that's because anyone who develops oop in Python is mentally ill.
Python is a scripting language, not to be confused with an actual programming language. Like everything else in development over the last decade, newbs are just shoehorning whatever is hot into the language because nobody is stopping them.
What 2003 forum thread did this comment crawl out of?
-
At least with Rust, there is a specific, defensible goal for why it does that.
Java is just over designed. All of
java.ioreads like somebody's Object Orientated Programming 101 final project, and they'd get a B- for it. Lots of things where you can see how they're abstracting things, but there's no thought at all in bringing it together in a tidy way.Not like C# is all that much better. So much garbage in the fundamentals just because it was done that way at the start and "they can't change it now". The best example is the IList interface.
Theoretically this interface exposes both index-based access and collection-like modifications and as such would be perfect in a function if you need those two features on a type. In reality you can't use it as a function parameter because half the official types implementing IList aren't modifiable and throw a runtime error. E.g Arrays
-
Sorry, I'm too Rust-pilled for this OOP nonsense
pub fn new() -> Self { Self::self().self.unwrap() }Even regular Rust code is more "exciting" than Python in this regard, since you have a choice between
self,&self, and&mut self. And occasionallymut self,&'a self, and evenself: Box<Self>. All of which offer different semantics depending on what exactly you're trying to do. -
I remember that a long time ago. Oh god
I remember this too... what a nightmare.
-
nah, I'm never complaining about
selfin Python after having tried thethisandthatnonsense in JS.oh, you're using a named function instead of an arrow fn? Guess what,
thisis not what it used to be anymore.Oh, you assigned a method to a variable before calling it? Congratulations,
thisis nowundefined. -
Not like C# is all that much better. So much garbage in the fundamentals just because it was done that way at the start and "they can't change it now". The best example is the IList interface.
Theoretically this interface exposes both index-based access and collection-like modifications and as such would be perfect in a function if you need those two features on a type. In reality you can't use it as a function parameter because half the official types implementing IList aren't modifiable and throw a runtime error. E.g Arrays
wrote on last edited by [email protected]That's a footgun sure but at least you can avoid it once you're aware of the problem.
I never write function signatures with mutable interfaces. It's always IEnumerable, IReadOnlyCollection, or IReadOnlyList; otherwise, use a concrete type. The latter is typical for private/protected methods that are called with instance members of a concrete type rather than public interfaces. If you want to mutate an object, you should own it. Public methods are invoked with data not owned by the instance.
For example, a lot of extension methods in LINQ have a signature IEnumerable<T> --> IEnumerable<T>, and internally the first thing they do is call .ToList(). The interface makes minimal assumptions about the input data, then puts it into a concrete type you can manipulate efficiently. You can similarly define a method for IReadOnlyList and explicitly make it mutable via .ToList(), rather than use IList and check .IsReadOnly. Both ensure correctness but the former does it at the type level, at design time, instead of relying on runtime checks.
C# is old and full of oldness. But it's also an excellent language that can be written beautifully if you know how. And there's lots of great code to learn from in the open-source dotnet core runtime repo and related projects.
-
You're right in that OOP feels very shoehorned in with Python. But not every project has a Linus Torvalds to publicly humiliate horrible ideas and implementations.
In what way does OOP feel shoehorned in with Python?
I ask since that is not my own impression of the language.Would you also be willing to share what language(s) you feel do(es) OOP without it being shoehorned in?
-
Reminds me of java
I have
Toolkit toolkit = Toolkit.getDefaultToolkit();seared into my brain. Then there were the bean factories…Now my brain wants to relate Java somehow to beancounters.
-
Even regular Rust code is more "exciting" than Python in this regard, since you have a choice between
self,&self, and&mut self. And occasionallymut self,&'a self, and evenself: Box<Self>. All of which offer different semantics depending on what exactly you're trying to do.I'll add that 100% of the above is understood by the compiler. Unlike Python or JavaScript where you don't know how bad you have it until the program is already running.
-
Write a new method, make sure to reference self first. Write a new method, make sure to reference self first. Call the method, make sure to reference self first.
Yeah, I can see it.
You don't reference self when calling a method, what on earth are you talking about?
You start with the instance when calling the method, like most/all other OOP languages.Also there are benefits with the explicit self/this to access instance properties.
In C++ you need to make sure all class properties/members have a naming scheme that does not conflict with potential parameter names or other names of other variables. -
In what way does OOP feel shoehorned in with Python?
I ask since that is not my own impression of the language.Would you also be willing to share what language(s) you feel do(es) OOP without it being shoehorned in?
Yeah, some weird accusations. Python has had classes since its inception (1.0).
Also the image in the post makes no sense. It shows multiple (Spidey) instances all pointing to each other which is not how self works.
self is just a parameter that may contain different instances depending how it was called. This is also true for any other parameters in any function, each time a function is called it may have a different instance. -
This post did not contain any content.
Break convention
`
class foo:
def init(cunt, bar):
cunt.bar=True`
-
Not like C# is all that much better. So much garbage in the fundamentals just because it was done that way at the start and "they can't change it now". The best example is the IList interface.
Theoretically this interface exposes both index-based access and collection-like modifications and as such would be perfect in a function if you need those two features on a type. In reality you can't use it as a function parameter because half the official types implementing IList aren't modifiable and throw a runtime error. E.g Arrays
Oh god, I didn't knew that. That's funny.
-
it's common practice as a workaround to save
thiswhen changing contexts, sincethismay change under you, in callbacks and suchKotlin:
[email protected] -
That's a footgun sure but at least you can avoid it once you're aware of the problem.
I never write function signatures with mutable interfaces. It's always IEnumerable, IReadOnlyCollection, or IReadOnlyList; otherwise, use a concrete type. The latter is typical for private/protected methods that are called with instance members of a concrete type rather than public interfaces. If you want to mutate an object, you should own it. Public methods are invoked with data not owned by the instance.
For example, a lot of extension methods in LINQ have a signature IEnumerable<T> --> IEnumerable<T>, and internally the first thing they do is call .ToList(). The interface makes minimal assumptions about the input data, then puts it into a concrete type you can manipulate efficiently. You can similarly define a method for IReadOnlyList and explicitly make it mutable via .ToList(), rather than use IList and check .IsReadOnly. Both ensure correctness but the former does it at the type level, at design time, instead of relying on runtime checks.
C# is old and full of oldness. But it's also an excellent language that can be written beautifully if you know how. And there's lots of great code to learn from in the open-source dotnet core runtime repo and related projects.
Functional programming fixes the problem by simply not making it OO anymore, and while I'm personally a big fan of the paradigm there are situations where an OO approach is preferable (or even only to conform to a project's existing way of doing things).
-
Functional programming fixes the problem by simply not making it OO anymore, and while I'm personally a big fan of the paradigm there are situations where an OO approach is preferable (or even only to conform to a project's existing way of doing things).
What I described isn't necessarily functional. This is just a principle for ensuring objects represent clear and well-defined contracts. The idea is that to mutate something, you should own it; that means interfaces / public APIs, which can be called externally, should take immutable arguments. You can still mutate instance members internally because those are owned by the instance. If mutation is really necessary between two objects then it should be coordinated by an object owning them both.
-
I'll add that 100% of the above is understood by the compiler. Unlike Python or JavaScript where you don't know how bad you have it until the program is already running.
At least python has a decent runtime typing system
JS's type system feels like what you'd get by giving a monkey access to unlimited cocaine and a computer
