Squeak Smalltalk on a PostmarketOS cellphone
Tue 25 Aug 2020 22:03 CEST
Part of a series: #squeak-phone
Back in 2007, when Openmoko was first a thing, I wrote an Erlang-based userland that got to the point of being able to take and make calls and receive and send SMS. The project stalled: the Openmoko GTA01 was too slow, its power-management too primitive, and Erlang’s GUI facilities too rudimentary to make further work worthwhile.
Modern cellphone hardware is much more capable. Is it time to have another run at the idea of a mobile personal computer?
PostmarketOS is awesome
Last week, I installed PostmarketOS on my previous cellphone, a Samsung Galaxy S7 (using PostmarketOS’s samsung-herolte configuration).
PostmarketOS turns out to be a beautifully engineered system that’s easy to understand and modify. The basics of kernel and Alpine Linux userland installed cleanly and easily on the phone, and it’s running well as a development platform. I’m looking forward to getting into PostmarketOS more deeply.
htop on the phone shows what an amazing little machine it
is! So much power. Loads of cores, lots of RAM. Plenty of space to
explore alternative visions of mobile personal computing.
However, the built-in demos, such as the Weston demo (shown above at right), currently leave quite a bit to be desired. Perhaps some of the other user interface options included with PostmarketOS could get me closer to a day-to-day usable cellphone - but I’m interested in running my own software! Let’s get hacking.
Running my own programs
PostmarketOS is a plain, clean Alpine Linux distribution. You can SSH into it initially via USB networking. From there, you can configure wifi using nmcli, set up SSH keys, and then access it directly using SSH over wifi.
Building software is just as simple:
To experiment with drawing to the framebuffer and reading touchscreen
/dev/input, I compiled and ran an old
quick and dirty framebuffer hack
I wrote years ago. The results (shown at left) were encouraging: the
program effortlessly animates tens of thousands of points at 30 frames
per second, responding to touch inputs. Display is via brute-force
pixel output to the
mmap‘d frame buffer. It doesn’t even use a full
PostmarketOS turns a phone into a fully capable Linux machine, with total control over the attached hardware, and with everything accessible to the developer in the usual places using the usual tools.
But Unix tools are inappropriate for a mobile personal computing platform. We’ll need something else.
A Smalltalk phone
Smalltalk could make an ideal basis for a mobile personal computing platform.
I’ve enjoyed using, developing with, and contributing to the Squeak Smalltalk implementation since the mid ’00s.
So I compiled the Cog Smalltalk VM on the phone itself, making use of the 64-bit ARM support code that landed extremely recently.
And lo and behold, it runs! Shown to the right is a bleeding-edge, fully up-to-date Squeak 6.0-alpha image running on the phone itself. (Click here or on the image to embiggen.)
From here, I can experiment with new ideas using the full power of a modern Smalltalk environment.
My previous Openmoko experiments foundered, in part, on the GUI aspect of the system; GTK+ via Erlang was fine for quick prototyping but wasn’t really up to the task for a day-to-day usable machine.
I recall getting Squeak running on my GTA01, in order to see if it could provide a viable UI. However, I remember being stymied by the mismatch between the expectations of the Smalltalk environment and the realities of the phone.
Squeak wants a mouse and keyboard. It assumes a monitor-sized display, in everything from widget and font sizes to window management. To work well on a phone, it needs a touchscreen-based, high-DPI UI in addition to its existing toolset.
Smalltalk, in both its language aspect and its system design aspect, also suffers from some weaknesses in areas where Erlang shines.
However, in the years since the GTA01:
the hardware is much better,
the Squeak VM and image are better,
I’ve learned a heck of a lot about some good ways to design interactive systems, and
I’ve recently built some tools that help bring Erlang- and Syndicate-style architectural patterns for concurrency to Smalltalk.
So I think using Erlang/Syndicate-style
Actors to structure a
Smalltalk-based phone userland, perhaps with
sub-virtual-machines and images, could work well.
My initial experiments have concentrated on
fixing the tiny fonts (the DPI-change support code in the image needs work, and the support in the VM seems to be absent (?)),
reading from the touchscreen (probably like this),
thinking about how to structure Actor supervision hierarchies and Dataspaces for a mobile phone (probably borrowing some design elements from my earlier Openmoko Erlang-based userland), and
thinking about how to layer a touchscreen (panel-based?) GUI atop Squeak’s Morphic UI.
I’ll write more on this blog under the tag #squeak-phone as things develop.