Re: Joy of this, Joy of that

On Sat, 23 Nov 2024 23:48:59 +0000, Pancho wrote:

To be honest, I don't have an idea what classes not being the
implementers of instance behaviour means. Where is instance behaviour
implemented?

From further up: “A behavior is the set of methods used by an object to
respond to messages”. Since a class itself has no such “behavior”, it
doesn’t need to be an instance of anything, unlike Python.

I would say C++ static methods and static variables are a hack.

 
They are there to provide access to the innards of a private/protected
class,

 
No, C++ static means class method or class variable.

There are no “class methods” or “class variables” as such in C++: in C
terms, they have “static linkage”. The “class” part is just a visibility
restriction.

Just as value types are a hack in C#. Things that are sensible for
performance reasons, but that add complexity.

 
Presumably, like Java, these mechanisms are there to avoid the need for
the services of the full language compiler at runtime.
 

No they are there for performance, because you don't want to have to do
a malloc and instance initialisation for every number you use.

Ah, like the distinction between “primitive types” and “reference types”
in Java.

Python manages to avoid this arbitrary separation: “int”, “float”, “str”,
“dict” etc are builtin types, and they are classes almost exactly like
classes you define yourself; and in particular you can subclass them.

Python also does multiple inheritance. And it does it quite nicely,
benefiting from lessons learned in earlier attempts at “linearization”
(coming up with a consistent and minimally-surprising method resolution
order across all the base classes).

 
Yeah, we discussed this in the past. I'm totally unconvinced of the
desirability of complex multiple inheritance linearization.

It is useful, for example, for creating enumerations of fixed instances of
some particular base class. You inherit from both your particular base
class as well as the generic “enum.Enum” base class, to get suitable
properties of both.

I'm actually quite unconvinced by Python.

Python manages to provide a small, powerful language core that includes
features that, for example, Java and C♯ had to leave out: lexical binding,
functions and classes as first-class objects, operator overloads,
arbitrary-precision integers, list comprehensions, dictionary and set
expressions, descriptors, metaclasses ... this then allows for library
modules to build on this core to provide powerful facilities in the form
of “domain-specific (sub)languages” (DSLs) that are specialized to
particular problem areas.

For example, you don’t need “generics” or “templates”, à la Java/C++ etc,
because you can define a “class factory” function that constructs new
classes at runtime.