[squeak-dev] Towards a more consistent and sensible implementation of #isAbstract

H. Hirzel hannes.hirzel at gmail.com
Sun Dec 10 13:16:07 UTC 2017


On 12/10/17, Marcel Taeumel <marcel.taeumel at hpi.de> wrote:
> Either way, this looks like we should strive for consistency first. At the
> moment, it is not only #= vs. #== but there are also forms like "self name =
> #Foo" as mentioned by Tobias. Even if we vote for #=, class name comparison
> seems inappropriate.

Seaside (Grease / jQuery) uses

GRAbstractDictionaryTest
isAbstract
	^ self name = #GRAbstractDictionaryTest

JSObjectTest

isAbstract
	^ self name = #JSObjectTest


> Best,
> Marcel
> Am 10.12.2017 11:09:17 schrieb Nicolas Cellier



> <nicolas.cellier.aka.nice at gmail.com>:
>
>
> 2017-12-10 9:53 GMT+01:00 Marcel Taeumel <marcel.taeumel at hpi.de
> [mailto:marcel.taeumel at hpi.de]>:
>
> So it comes down to what "being abstract" actually means in the environment.
> :-) I think it means #== considering the current VM and the role of classes.
+1

> Not sure in a the generic, object-oriented sense, though.
>
> Best,
> Marcel
> Am 10.12.2017 00:02:06 schrieb Chris Muller <asqueaker at gmail.com
> [mailto:asqueaker at gmail.com]>:
> With objects you should delegate to the the receiver to decide what #= means
> -- which in most cases will inherit that default implementation from Object
> anyway.  Sending #== is generally bad form.

Bad because of what?

> Converting uses of #= to #== for "performance" is a bad idea except in the
> most inner, performance-critical code, and even then, it should be with a
> comment.
>
> Absolutely, if it's only for the sake of optimization, it's a bad decision.
> Not to mention that isAbstract is not performance critical at all.
>
> Maybe the intention is to really test for identity.
+1
> That's because we have the knowledge that classes are the unique instance of
> their metaclass.
+1

 So using = could be seen as an un-necessary indirection.

+1
> Reducing the level of indirection may reduce complexity.

> But it is also reducing extensibility as noted by Marcel.

In  which sense?

>
> But do we want to elimiate complexity at all?
> I see this related to "complex versus complicated" and the original
> biological analogy.
> Are resilient/adptative systems necessarily complex?
>
> If so, ideally such complex system should be built from simple
> behavior/rules.
> What we want to avoid if possible is complicated things.
>
> Nicolas
>
>
> On Thu, Dec 7, 2017 at 2:30 AM, Marcel Taeumel <marcel.taeumel at hpi.de
> [mailto:marcel.taeumel at hpi.de]> wrote:
>
> Hi, there.
>
> What are your thoughts on how to implement "MyClass class >> #isAbstract"? I
> think that one should always use #== and compare it to an actual class
> object like this:
>
> MyClass class >> #isAbstract
>    ^ self == MyClass
>
> At the time of writing, we have various attempts in your image. You can
> browse them easily:
>
>
> Best,
> Marcel
>
>
To summarize: We need a definition of what 'isAbstract' means and how
it should be implemented.

BTW Pharo has the same problem. Different implementations, including

isAbstract
    ^ true

or

isAbstract
    ^ false


--Hannes


More information about the Squeak-dev mailing list