Category: Technology

I recently learned a lot about CycleJS, which had been recommended to me in the category “you probably won’t use this for your day job right now, but you will learn a lot by looking”. And indeed, it has turned out to be the case. Cycle can be thought of as an answer to the question “what if we only had Observables and virtual DOM ? Would that be enough to build applications?” It appears to me that the answer is yes, though the tooling is not really all that complete yet.

Along the way I wrote a small example application and recorded a series of short videos (below) explaining some of the things I learned along the way, how to use various Cycle features, and especially about interesting points of comparison between Cycle and Angular and React.

These videos are not an introduction to Cycle, nor do they replace the documentation. Rather the idea is to give a flavor of how things work in Cycle from an application developer point of view, compare and contrast with other approaches, and point out why some of the ideas are quite valuable even if initially not obvious.

As I write this, have recorded four videos and made it about 70% of the way through the example application, talking through how it works and why. Questions and suggestions are much appreciated, probably the best place to put those is in the issue tracker of the example application linked above.

 

 

 

 

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

• http://squeak.org/
• Free, open source
• Appeared in the early 2000s
• … from some smart people at Disney
• Somehow become open source, a very rare thing at Disney
• Pretty similar to the original Smalltalk
• Its own UI, non-native, looks pretty non-native
• Cog VM http://www.mirandabanda.org/cogblog/about-cog/

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

• http://www.cincomsmalltalk.com/main/products/visualworks/
• Commercial, expensive, supported
• Native UI, though perhaps not very “2017”
• Optimized in various commercial ways

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

• Seaside.st http://seaside.st/
• (others, I’m sure)

(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?

• (ancient?) gurus
• Financial companies making zillions
• Complex manufacturing control
• Insurance
• Research / university / learning
• https://montykamath.wordpress.com/smalltalk-companies/
• http://stackoverflow.com/questions/711140/why-isnt-smalltalk-popular

Learning more

• https://www.youtube.com/channel/UCp3mNigANqkesFzdm058bvw
• MOOC
• Books
• Fair amount of code on Github and elsewhere

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.

 

Angular component libraries don’t ship with AOT “ngfactory” output. Why not?

Angular 2-and-up (I’m working with the version 4 release candidate at the moment) is a relatively large and complex single page app framework/library, but unlike some of its smaller competitors it has a key feature to mitigate this and provide a performance boost in deployment.

The feature is “ahead of time compilation”. With AOT, HTML templates used by an application are parsed/compiled during the build process, rather than when they are used in the running application on a web page. This compilation converts the textual templates to TypeScript classes, which are then bundled along with human-written application code. As a result, with AOT large portions of the Angular framework can be excluded from the deployed application.

AOT is typically performed with a command line program “ngc”, in an application build process.

But what about libraries of pre-built Angular components? Should a component library (which might be published as a NPM package, or by some other means) include this AOT output, which takes the form of “*.ngfactory.ts” files?

No – Angular itself does not work this way and build tooling does not support or encourage such a thing. If it did encourage bundling the AOT output libraries:

• Libraries would not benefit from further improvements to AOT, without also releasing out a new version of the package.
• AOT would need to generate code which works across version skew, in order to respect semver. this would be a frequent and problematic restriction.

The actual implementation of AOT expects AOT to be performed always at a project level and never at a library level (although the letter is not exactly true; you may use the AOT tool in the library to produce “metadata” files).  With this design, you can consume a library written (for example) with Angular 2.3.3, even if your project is using Angular 2.4.5 (somewhat different AOT output) or Angular 4.x (very different AOT output).