Month: June 2017

Smalltalk

Much of my work (as a technology guru at Oasis Digital) is around the intersection of the most current technology (such as Angular) with existing complex, valuable systems used by our customers. Recently an opportunity came up in which we may interact with some older software written in Smalltalk. I’ve used Smalltalk a bit some years ago, but many of the others at work have not.

To help our team understand a bit about Smalltalk, I demonstrated some of the basics (with Pharo, a surprisingly nice open source implementation) and spoke a while. At the end, someone pointed out that many of the words and the slides might be useful as a blog post for future reference.

What is Smalltalk?

History

  • Advanced technology – from an earlier era
  • http://worrydream.com/EarlyHistoryOfSmalltalk/
  • Smalltalk-76, -80
  • Byte magazine Smalltalk issue – see PDF available online; this issue seemed like sheer magic when I stumbled across it (already worn and tattered) in a library in the mid-1980s.
  • In some ways Smalltalk was decades ahead of its time
  • Descendant of “the mother of all demos”
  • Predecessor of much of what we use today
  • Alan Kay, 1971, “The best way to predict the future is to invent it.”

The basics

  • One of the first OO languages
  • (very) dynamically typed
  • Everything is an object
  • Syntax quite different from most of what we use today
  • Runs on a virtual machine (like JS, Java, .NET, etc.)
  • Contains many ideas that set underneath much of what we do
  • Environment consists of many live objects, developer can manipulate
  • Those live objects reside in an “image”, which can be persisted, shared, deployed

Implementations

Squeak

SqueakJS

  • https://squeak.js.org/
  • Free, open source
  • not what you might guess!
  • Smalltalk VM, run in a browser
  • Not very practical, too many layers of VM

Pharo

  • http://pharo.org/
  • Free, open source
  • Fork of Squeak
  • Generally newer, more polished look
  • Old things cleaned up
  • As far as I can tell, still using the same VM as Squeak, Cog VM
  • Non-native UI, looks quite nice

VisualWorks

Connecting to the world

Source control

  • You don’t write Smalltalk as a pile of files
  • Instead, manipulate classes etc, inside an image
  • Tooling adapts this to a file structure…
  • … when you then can put in source control for collaboration
  • The result is a repository with numerous small files, which maps to and from native Smalltalk code
  • Monticello – let’s look at it.
  • Future thing – Iceberg – use this to understand the image-to-file mapping. https://github.com/pharo-vcs/iceberg

Files

Smalltalk runs in an image, but many/all implementations also provide all the primitives you need to talk to files.

Networks

Many/all implementations also provide all the primitives you need to talk to networks, plenty of protocols, etc.

(server-side) web apps

(single-page) web apps

  • Nothing that I know of, to write these in Smalltalk
  • … but an Angular or other modern web UI could sit on a Smalltalk server

Databases

There are:

  • Drivers for SQL databases
  • Drivers for NoSQL databases
  • Object databases written in Smalltalk

Human factors

Community

There is one. I’m not in it. Who uses Smalltalk today?

Learning more

Thoughts on framing.io

I just participated on the panel for an ngHouston online user group meeting, where Ryan Campbell of BizNas / framing.io presented the Framing framework for complex enterprise Angular applications. You can watch a replay here:

Here is a quick analysis, pros and cons of Framing and its approach. Keep in mind as I write this: Framing has just recently been released and is at the very beginning of working to build a user community.

Pros

Ryan pointed out that, at a certain scale, enterprise teams tend to eventually build something in the general direction that Framing has gone… And he is completely right. Angular’s built-in abstraction for building aggregate of more than one component, NgModule, is still relatively low level, and provides just some low-level structure. It does not provide a pattern to follow around how an application feature could be structured, or other patterns. Teams building large sprawling systems tend to want a more structured way to follow consistent patterns across highly numerous features. Framing provides such a pattern and tooling.

In our work teaching and consulting on Angular, we have met groups who have built things generally like this under AngularJS 1.x, though I don’t think I’ve seen anything similar published for 1.x. Framing is the first thing of its general nature I have seen published for Angular 2+. Actually getting something published is always impressive and worthy of appreciation, there are probably dozens of other somewhat similar libraries/frameworks scattered around the industry, hidden behind firewalls.

Framing appears to have avoided many of the obvious ways that a framework like this could go wrong. There are numerous plug points and overrides available. An application can pick up a feature, and override display strings, data, components use inside the feature, chunks of code used inside the future, and so on. An application can do this without “forking” or copying all of the unchanged code in the future.

Although at first glance it seems like Framing might override the Angular way of doing some things, with a deeper look it seems instead that it provides an additional higher-level, more abstract API for building Angular applications at scale. This API is oriented toward composability and reusability, and a coarse-grained way that the core Angular obstructions are not.

Cons

There are risks, of course. The obvious ones include:

  • Framing might turn out to be 80% good enough but not 100% good enough, and that might be discovered after having built mountains of code.
  • Framing might turn out to be great for a while and then get abandoned, making it to Angular 6 but not Angular 7 for example.
  • Framing might turn out to be completely against the grain of some future change in Angular, such that it really can’t be updated but rather must be re-architected completely.
  • … and more.

Ryan mentioned that there is a path by which they believe they can make Framing fully AOT compatible, but I’m skeptical of this until I see it running. AOT relies on static analysis of the module structure, it’s not perfectly clear that it is possible to perform static analysis of something built this way. (This reliance on static analysis is perhaps the greatest strength and greatest weakness of Angular!)

Framing comes with its own dataflow/reactivity library and approach. This approach might be ingenious, but it is undeniably much less popular and proven than the Redux-flavored design offered by ngrx/store, which seems to be well on the way to “de facto standard” for complex Angular applications.

Learning Angular, learning the many of libraries people typically use with Angular, teaching those things to others, is already a really big challenge. Another additional abstraction like Framing on top, adds to a tall stack of things that have to be learned and taught. This challenge of teaching and learning so much to so many, is already one of the bigger concerns for large organizations (the kind of folks who would benefit from something like Framing) adopting Angular. (Marketing plug: at work at Oasis Digital, we help with the sort of thing, and we teach Angular at Angular Boot Camp.)

Conclusion

Framing is definitely worth a look, and I will follow its ongoing development. I recommend others responsible for sprawling applications do so also.