T.H.O.R.

Transformative Humanistic OOP Reality

T.H.O.R. is a vision of the future of software development where the creative spirit in human beings is harnessed to create great software with tremendous ease and velocity [1]. This is software creation with much less friction than in conventional development practices (using file-based tools like JavaScript, Java, Python, and C++). The tool at the heart of T.H.O.R. is the Smalltalk programming language.

What are the elements of T.H.O.R. that make this a reality?

First is the impossibly clean syntax of Smalltalk. Everything in Smalltalk is an object, and objects perform actions by sending them messages. So the fundamental syntax is:

anObject aMessage

…meaning that you send aMessage to anObject. That’s it! All of Smalltalk programming is reduced to this one thing [2].

Messages come in three flavours: unary, binary, and keyword. Unary messages are singular words like ‘squared’ or ‘getBalance’. Binary messages are inserted between two objects, like

rate < 3.0

where ‘rate’ and ‘3.0’ are the objects and ‘<’ is the binary message.

Keyword messages are the most interesting because they take on a parameter, for example:

isTaxable and: rate < 3.0

This is a logical expression that tests the truth of ‘isTaxable’ and the parameter ‘rate < 3.0’ (which is also an expression) to the ‘and:’ message.

As you might expect, the order of precedence for messages is:

• Unary first
• Binary second
• Keyword last

Within each precedence level, messages are evaluated left to right; parentheses may be used to alter the order.

The result is syntax that reads a lot like English or natural language. (This is unlike Lisp, another language with an extremely clean syntax. Lisp’s “unnatural” prefix notation and torrent of parentheses make the language harder to read.)

The value of such a clean, simple syntax must not be underestimated. It presents an absolutely minimal cognitive load on the developer which makes it much, much easier for him/her to master the tool. When you’ve mastered the tool, you can work at your maximum effectiveness and efficiency.

Secondly, Smalltalk has a fantastic lively exploration-on-demand system. This system allows you to get instant feedback about any object in your application or the Smalltalk base system! Nothing is hidden from you. Not only can you inspect an object’s properties, you can also modify the code in any of its methods and continue execution!

This ability to alter the running code is a crucial aspect of the Smalltalk debugger, which is an incredibly powerful tool unmatched in the conventional programming world (sorry, Eclipse and Visual Studio)…unmatched both in terms of elegance and convenience.

Third is the consistency of the Smalltalk programming model. It is much simpler than, for example, hybrid models found in Scala, C++, and JavaScript. It eliminates the “schizophrenia” of mentally switching between procedural, object-oriented, and functional styles, and even between dynamic and static typing (C#, Dylan, and Alore come to mind; the Dart language has “type annotations”)! This allows you to think more directly and consistently on the problem, and thus work more efficiently.

The combination of syntactical simplicity, instant feedback, consistency, and superlative debugger creates a synergy that does not exist elsewhere in the IT industry (though Lisp/Scheme comes close). This synergy has two implications. One, programming is much more intuitive and aids in unleashing your creativity. Two, your productivity is greatly amplified, letting you write your application in a fraction of the time it takes in other languages [3].

To be sure, Smalltalk isn’t quite ready for primetime yet. But the promise is there and the Smalltalk community is very actively working to deliver on this promise.

Smalltalk faces obstacles because its user community is relatively small and thus its ecosystem has not had a chance to grow into the big systems we see with JavaScript, Java, Python, and C++. T.H.O.R. requires a decision to adopt Smalltalk, knowing that it will take time and energy for it to evolve into the fabulous tool it can be. For now, however, Smalltalk is eminently usable and a powerful development environment that has the potential to transform the future of software creation.

This is our reality. Make it yours [4].

References

[1] My thanks to Sebastian Sastre. http://qr.ae/RHieVq
[2] There’s a wee bit more syntax for blocks (which are closures and higher order functions), but that’s basically it.
[3] See https://smalltalkrenaissance.wordpress.com/2015/02/16/smalltalks-proven-productivity/
[4] What are the biggest obstacles to adopting Smalltalk?