Re: Joy of this, Joy of that

On 11/24/24 00:31, Lawrence D'Oliveiro wrote:

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.
 

What?, Classes do have methods, e.g. they should handle a "new" message to create a new instance object of that class.
In my previous post I didn't understand the meaning of implementation. Informally I think of implementation as my code, my definition of a function, as opposed to declaration. For instance I might say  a class implements an interface. However I think the article you cited was using the word implementation to mean compiler. i.e. implementation of the Smalltalk language.
 From my perspective this is irrelevant, because my understanding of Smalltalk was conceptual. The Smalltalk-80 Bluebook spoke of classes as normal objects which had methods, responded to messages. The class which created instance objects of type class was a metaclass.
The fact that a compiler/interpreter might handle (implementation detail) all class behaviour, as it does in C++, doesn't matter. It is helpful to think of classes as objects in their own right.
The problem is that the OO model for C++ is more complex. It is easy to not be able to see the wood for the tress. That is why I was lucky to have the Smalltalk conceptual model before being introduced to C++,

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.
 

static has many usages in C++. You seem to be confusing the C definition of a static variable with internal linkage, with the idea of a C++ class static member variable or method.

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.
 

Possibly. Reference types are like pointers. Value types can live only on the stack.

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.
 

In practice I didn't care. Generics solved the main problem of using value types in container classes, without having to box 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.
 

Like an interface, IEnumerable (Chsarp), Iterable(Java)? or are you back to some special use for Enums.

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.
 

Python is very pretty, the problem is that I tried to write some programs using it and the libraries were buggy. With CSharp and Java the standardish libraries seem more reliable.

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.

Yeah, I find not having explicit types very difficult to handle. Maybe that is prejudice, maybe not.