Why Smalltalk is NOT Object-Oriented, Part Two: Self and Topology


Why Smalltalk is NOT Object-Oriented

Part Two: Self and Topology

Self and topology might not be the first notions that one might think of as belonging together. However there is an intrinsic manner in which they do belong together, and it is through this intertwining that much of Smalltalk’s power when compared with other “object” languages comes about.

I ended the first part by describing a Smalltalk “thing” as essentially what Aristotle meant when he coined the term ‘entelechia’. Although the term has gained some traction in the biological sciences, it has largely been ignored in the spheres of mathematics and physics, although much of the latter is dependent on it, and the former suffers greatly from its lack. The polymath Leibniz reintroduced the word into physics, in the process introducing into physics much of its current content, specifically the area of physics known as dynamics, as opposed to statics, which modern physics until Leibniz had ignored.

From the more purely mathematical perspective, what differentiated an entelechia for Aristotle from any other gathering would be expressed as the difference between a system and a set, i.e. the manner in which a set is a set is arbitrary, while a system is functional. The irony is that mathematics itself is systemic, indeed emergently so, yet properly speaking it does not acknowledge the concept, since a system can never be based on sets, and sets are the foundation of post-Cantorian mathematics. (note: I’m not making the absurd claim that mathematics is not used to describe systems, merely that the notion of system is not foundational, or even properly grounded, in modern mathematics).

The long-standing influence of reductionism has been part of the difficulty, as has the gross absurdity that refers to itself as modern mereology. But whatever the reasons for the difficulty, modern mathematics is itself determined at the limit by properties of system, yet does not properly speaking have that very concept in any clarified manner. Since there is no means by which those properties could be subject to a proof via set theory, it appears as if post-Cantorian mathematics itself suffers a serious and perhaps catastrophic defect, one that might provide a direction in which mathematics may overcome many of its other weaknesses.

To get to the more immediate point, however, as entelechia Smalltalk “things” not only are self-referential and to a degree self-knowledgeable, they can act on the assumption that all other Smalltalk “things” have the same basic abilities. Of course this self-referentiality and self-knowledge are perhaps as minimal as they could be and still retain those descriptions, but it is precisely this that differentiates Smalltalk from other “object” languages. The seemingly minimal difference between “self” in Smalltalk terms and “this” in Java terms is not simply “all the difference in the world”, but the difference between world and environment, in the most basic, minimal senses of each.

What does it mean to say that, even in the most minimal of senses possible, a Smalltalk image is a “world” while a Java VM, without extensive additions not usually present, is not a world but merely an environment? It is in attempting to answer this that the belonging-together of self and topology has to be clarified.

While we associate “world” with self-aware consciousness and specifically with language insofar as it is understood linguistically, it remains the case, for instance, that higher animals not considered to be conscious in a properly self-aware manner, nor possessing language outside its semiotic sense, nevertheless do possess world, in Heidegger’s phrase, they are “poor” in world, but they are not bereft of it in the sense that insects have only environment. Certainly they are not ontological in the sense that human beings are: they cannot experience anything as such, for instance a tree as a tree. Yet they certainly experience the tree in a manner not simply beyond the capacity of a bee, but completely outside its realm.

This all may be interesting, but initially it seems irrelevant to software at least as it exists today, particularly in languages neither intended nor heavily used for what passes for AI. While we may say the bee doesn’t experience the realm of a higher animal even in a lowered capacity, software doesn’t experience at all. Any “knowing”, properly speaking, either originates with the developer, or is emulated in a more or less useful fashion by large networks of unaware correlations. Nor am I in any way implying that Smalltalk somehow goes beyond these two modes of “knowing”. However the power of a consciousness is in direct relation, not only to its self-awareness, but also to its ability to “have a place” in something that is determined, like world, by a network of relations that is not fixed, but is constantly redetermined by every change, even the most minor in the least important facet.

This “something” is topology, and it is what we experience when we speak of context. Topology is the determination and appropriation of place that secondarily determines the appropriateness of anything specific in a given context, yet is in turn constantly redetermined by everything specific in every context.

What makes a Smalltalk virtual machine, or image, topological in a different manner from a virtual machine in Java, Python, or even LISP, is firstly the manner in which a Smalltalk entelechia takes care of its own aspects. The second is the manner in which such an entelechia, as an instance, has a simultaneous jointure and specific difference from its essence, its class. The third is that, at least as essence, as class, all entelechia in any given Smalltalk world are live, i.e. they have state. Lastly, and perhaps most importantly, it arises from their ability to respond to changes in the world not merely by a change in behaviour but by self-modification, via morphing or shape-changing, which creates a simultaneous change in world, one that may be minor or that may to a massive degree change the ‘meaning’, the ontological status, of every entelechia present.

These abilities, simply, are not abilities of objects (nor mathematically speaking are they abilities of anything that could be set based). In practical terms, new abilities introduced by new entelechia (newly written or loaded classes) can not only change the abilities of classes that already exist, but can a priori modify the abilities of classes not yet written or loaded. This ability to affect the Smalltalk image both backwards and forwards is very powerful, and accounts for the phenomenal productivity of a skilled Smalltalk developer (estimated by Capers Jones, one of the inventors of rational software metrics, at 3x the productivity of a Java or Ruby developer and nearly 30x the productivity of a JavaScript/HTML developer. The combination of dynamic typing with strong typing allows the Smalltalk tooling to gain the flexibility associated with Ruby or JavaScript together with the analysability of Java, and without the arcane syntax of the latter two. Ruby looks and ‘feels’ much like Smalltalk, with a similar message passing paradigm, but its lack of strong typing has led to an inability to write decent tooling, and an inability therefore to allow the kind of topological morphing done in Smalltalk, which accounts for the real power of the latter. Putting a syntactical sugar onto what is at root just another scripting language does not make Ruby a “new Smalltalk”.

Interestingly, the Greek term from which system is derived contained within it the ambiguity between system in the proper sense and set as what is merely “shoved together” arbitrarily with no intrinsic jointure. As well, the Greek term contained a third meaning, that which is a midpoint between the two, and in its intended meaning we would describe such a midpoint as a framework.

The proliferation of frameworks in Java and lately in JavaScript is as much an admission of the failure of those languages to offer the abilities of a language such as Smalltalk as it is an attempt to bridge the gap. As a half measure, though, a framework can only achieve so much in terms of modifying a language such as Java to make it more “Smalltalk-like”. The Eclipse development environment has been around for 15 years now, and either contains or supports hundreds of such frameworks, while itself being built on the most “Smalltalk-like” Java framework that exists – OSGi. Properly written OSGi bundles have much of the intra-activity and ability to modify one another’s behaviour that is inherent to a Smalltalk entelechia. There are two main problems with this approach, however:

1. Efficiency. Since OSGi bundles must be written in a certain manner for the OSGi container to provide some of the capabilities of a Smalltalk “world”, it adds a significant additional burden of code that must be written within the Java class. Worse, the OSGi container itself becomes another layer of virtualization trying to overcome the limits of the Java virtual machine, which are initially determined by the limits of the language. The result is a triple combination of inefficiencies in terms of coding productivity, runtime performance and additional configuration, the latter costing significantly more in productivity than the additional coding.

2. Reliability. Not only is there significant additional code and significant interacting configuration, areas that present significant risk for introduction of defects. The OSGi framework itself, since it is written in Java, suffers from the same liabilities inherent in using passive “objects” from other objects where the calling object’s author is likely to know the called object insufficiently, introducing programmatic errors. This is compounded by the relatively passive response of the entire Java system to its environment, which leaves it open to subtle, difficult to resolve defects that are most often environment specific, i.e. they only happen at some sites and not others. This last weakness is the single biggest reason for throwing out entire codebases, and the single biggest reason that despite the apparent advantages of modularity, all of our most reliable systems remain monolithic.

Advertisements

Leave a Reply

Please log in using one of these methods to post your comment:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s