If I've been a bit quiet recently it's not due to lack of progress, but rather the very opposite: so much progress in
Objective-S land hat my head is spinning and I am having a
hard time both processing it all and seeing where it goes.
But sometimes you need to pause, reflect, and show your work, in whatever intermediate state
it currently is. So without further ado, here is the distributed system, with GUI, in a tweet:
It pops up a window with a text field, and stores whatever the user enters in an S3 bucket.
It continues to do this until the user closes the window, at which point the program exits.
Of course, it's not much of a distributed system, particularly because it doesn't
actually include the code for the S3 simulator.
Anyway, despite fitting in a tweet, the Objective-S script is actually not code golf, although it may appear as such to someone not familiar with Objective-S.
Instead, it is a straightforward definition and composition of the elements required:
- A storage combinator for interacting with data in S3.
- A text field inside a window, defined as object literals.
- A connection between the text field and a specific S3 bucket.
That's it, and it is no coincidence that the structure of the system maps directly onto the structure
of the code. Let's look at the parts in detail.
S3 via Storage Combinator
The first line of the script sets up an S3 scheme handler so we can interact with the S3 buckets
almost as if they were local variables. For example the following assignment statement stores
the text 'Hello World!' in the "msg.txt" file of "bucket1":
s3:bucket1/msg.txt ← 'Hello World!'
stdout println: s3:bucket1/msg.txt
http://defiant.local:2345/, so running on host defiant in the local network, addressed by Bonjour and listening on port 2345. As Objective-S supports Polymorphic Identifiers (pdf),
this URL is a directly evaluable identifier in the language.
Alas, that directness poses a problem, because writing down an identifier in most programming
languages yields the
value of the variable the identifier identifies, and Objective-S is no exception. In the case of
http://defiant.local:2345/, that value is the directory listing of the root of the S3 server, encoded as the following XML response:
<?xml version="1.0" encoding="UTF-8"?>
<ListAllMyBucketsResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
<Owner><ID>123</ID><DisplayName>FakeS3</DisplayName></Owner>
<Buckets>
<Bucket>
<Name>bucket1</Name>
<CreationDate>2022-08-10T15:18:32.000Z</CreationDate>
</Bucket>
</Buckets>
</ListAllMyBucketsResult>
That's not really what we want, we want to refer to the URL itself. The ref: allows
us to do this by preventing evaluation and thus returning the reference itself, very similar to
the & operator that creates pointers in C.
Except that an Objective-S reference (or more precisely, a binding) is much richer than
a C pointer. One of its many capabilities is that it can be turned into a store by sending it
the -asScheme message. This new store uses the reference it was created from as its
base URL, all the references it receives are evaluated relative to this base reference.
The upshot is that with the s3: scheme handler defined and installed as described, the
expression s3:bucket1/msg.txt evaluates to
http://defiant.local:2345/bucket1/msg.txt.
This way of defining shorthands has proven extremely useful for making complex references usable
and modular, and is an extremely common pattern in Objective-S code.
Declarative GUI with object literals
Next, we need to define the GUI: a window with a text field. With object literals, this
is pretty trivial. Object literals are similar to dictionary literals, except that you
get to define the class of the instance defined by the key/value pairs, instead of it
always being a dictionary.
For example, the following literal defines a text field with certain dimensions and assigns it
to the text local variable:
text ← #NSTextField{ #stringValue:'',#frame:(10@45 extent:180@24) }. window ← #NSWindow{ #frame:(300@300 extent:200@105),#title:'S3', #views:#[text]}.
Connecting components
Now that we have a text field (in a window) and somewhere to store the data, we need to connect
these two components. Typically, this would involve defining some procedure(s), callback(s) or
some extra-linguistics mechanism to mediate or define that connection. In Objective-S,
we just connect the components:
text → ref:s3:bucket1/msg.txt.
The right-arrow "→" is a polymorphic connection "operator". The complete connection is
actually significantly more complex:
- From a port of the source component
- To a role of the mediating connector compatible with that source port
- To a role of the mediating connector compatible with the target object's port
- To that compatible port of the target component
If you want, you can actually specify all these intermediate steps, but most of the time
you don't have to, as the machinery can figure out what ports and roles are compatible.
In this case, even the actual connector was determined automatically.
If we didn't want a remote S3 bucket, we could also have stored the data in a local file,
for example:
text → ref:file:/tmp/msg.txt.
text → ref:var:message.
Alternatively, we could also append the individual messages to a stream, for
example to stdout:
text → stdout.
text → ref:file:/tmp/msg.txt outputStream.
I hope this makes it clear, or at least strongly hints, that this
is not the usual low-code/no-code trick of achieving compact code
by creating super-specialised components and mechanisms that work
well for a specific application, but immediately break down when
pushed beyond the demo.
What it is instead is a new way of creating components, defining
their interfaces and then gluing them together in a very straightforward
fashion.
Eval/apply vs. connect and run
Having constructed our system by configuring and connecting components, what's
left is running it.
CLIApp is a subclass of
NSApplication
that knows how to run without an associated app wrapper or
Info.plist
file. It is actually instantiated by the
stui script runner before
the script is started, with the instance dropped into the
app variable
for the script.
This is where we leave our brave new world of connected components and
return (or connect with) the call/return world, similar to the way Cocoa's auto-generated
main with call to NSApplicationMain() works.
The difference between eval/apply (call/return) and connect/run is actually quite profound, but
more on that in another post.
Of course, we didn't leave call/return behind, it is still present and useful for certain
tasks, such as transforming an element into something slightly different. However, for
constructing systems, having components that can be defined, configured and connected
directly ("declaratively") is far superior to doing so procedurally, even than the
fluent APIs that have recently popped up and that have been mislabeled as "declarative".
This project is turning out even better than I expected. I am stoked.
