We’ve seen a couple of examples of frontend Caffeine development, using jQuery UI and voxel.js. Let’s look at something on the backend, using Node.js and something I like to call tweetcoding.

Social Livecoding

Livecoding means having all the capabilities of your development environment while your system is live. Runtime is all the time. Smalltalk programmers have always enjoyed this way of working. It is particularly effective in domains such as music performance, where the ability to make changes while your system is running is critical, both for fixing bugs and for artistic expression. One of my artistic goals with musical livecoding (writing code that makes live music for an audience) is audience accessibility. I want the audience to have some understanding of what’s going on in my code, even if they aren’t coders (yet).

Another aspect I like to incorporate is audience participation. If the audience actually does understand what I’m doing in my code, why not let them join in? Social media has become a ubiquitous communication platform; billions of people are using it with prose and pictures. I think the time has come to use it with live code as well. Nearly everyone in the audience has a powerful computer with social media access in a pocket. We can all livecode together.

Let’s Do This

We need three things to make this happen: a way for people to submit code, something that listens for that code and evaluates it, and a shared artifact everyone can see that shows the code’s effects. I like Twitter as a coding medium, for its minimalism. It also has a culture of hashtag use, and a streaming API, which make listening for code straightforward. For the shared artifact, we can use something viewed with Caffeine in a web browser.

For our first example, let’s use something simple for our coding domain, like turtle graphics. A person can tweet instructions to a turtle which draws on a square piece of paper, 100 units on a side. There are four commands:

color , for the turtle to change its pen for one of the given color

, for the turtle to change its pen for one of the given color down , for the turtle to put its pen down on the paper

, for the turtle to put its pen down on the paper rotate , for the turtle to change direction

, for the turtle to change direction move , for the turtle to move some distance

, for the turtle to move some distance up, for the turtle to take its pen up from the paper

We’ll say that that the turtle can be identified by some ID, and is initially at the center of the paper. A tweetcoded instruction for the turtle might look like:

Tweetcoding tweets start with the #tweetcoding hashtag, so people seeing one for the first time can look at others with that hashtag, to see what it’s about. This is followed by hashtags identifying our turtle-graphics protocol, and the turtle we’re using. We end the tweet with a drawing instruction, using our instruction set above.

Livecoding NodeJS

To detect these tweets, we’ll use the Twitter streaming API from Node.js. In the spirit of livecoding, we won’t use an application-specific Node.js module for this directly, but instead inject JavaScript code live into a Node.js instance, from Caffeine in a web browser. I’ve written a node-livecode Node.js module which takes commands over a websocket. It starts with three instructions:

require , for loading another Node.js module into itself with npm

, for loading another Node.js module into itself with npm add instruction , for adding an instruction to itself

, for adding an instruction to itself eval, for evaluating JavaScript code

You can see the implementation at GitHub. It can use SSL to keep injected code secure in transit, so you may want to set up a certificate for your server with Let’s Encrypt. Also note that it exposes the listening server as a global variable, so that you can use it in your injected code.

Once we have node-livecode on a server listening for commands, we can inject code into it from Caffeine. First we’ll inject code to listen to #tweetcoding tweets from Twitter:

| websocket | websocket := JS WebSocket newWithParameters: {'wss://yourserver:port'}. JS top at: #websocket put:websocket. websocket at: #onmessage put: [:message | Transcript cr; nextPutAll: message data asString; endEntry]; at: #onopen put: ( (JS Function) new: ' window.top.ws.send(JSON.stringify({ credential: ''shared secret'', verb: ''require'', parameters: { package: ''node-tweet-stream'', then: '' var Twitter = require(''node-tweet-stream'') , twitter = new Twitter({ consumer_key: '''', consumer_secret: '''', token: '''', token_secret: ''''}) twitter.on( ''tweet'', function (tweet) { if (instructions[''broadcast'']) { instructions[''broadcast''](tweet)}} twitter.on( ''error'', function (err) { console.log(''error in uploaded code'')}) twitter.track(''#tweetcoding #turtlegraphics '')''}})))

The example above uses handwritten JavaScript code, but we could also use Caffeine’s JavaScript code generation to produce it from Smalltalk code (see the method MethodNode>>javaScript for the implementation). Also, since we’ll be injecting several things, it would be nice to have a more compact way of writing it. Let’s move that workspace code to a class.

Next we’ll inject a new instruction, for initializing a set of drawing-command listeners:

| client | client := ( NodeJSLivecodingClient at: 'wss://yourserver:port' withCredential: 'shared secret'). client addInstruction: 'initialize listeners' from: ' function () { global.listeners = [] return ''initialized listeners''}'

To round out our tweetcoding protocol, we’ll add instructions for accepting listeners, and broadcasting tweets detected from Twitter:

client addInstruction: 'start listening' from: ' function () { listeners.push(this) return ''added listener''}' addInstruction: 'stop listening' from: ' function () { listeners.splice(listeners.indexOf(this), 1); return ''removed listener''}' addInstruction: 'broadcast' from: ' function (payload) { listeners.forEach( function (listener) {listener.send(payload)}) return ''broadcasted''}'

Putting It All Together

Now we can write other Smalltalk classes which subscribe to tracked tweets from the server, and collaborate to do something interesting with them in the web browser. I’ve implemented the following classes:

Object NodeJSLivecodingClient TweetcodingClient TurtleGraphicsTweetcodingClient Turtle Tweet

Instances of NodeJSLivecodingClient can inject code into a node-livecoding server, and invoke code added by other clients. Instances of TweetcodingClient can also set tracking filters for tweets, and process matching tweets when they occur. Instances of TurtleGraphicsTweetcodingClient can also control Turtles, which can draw on canvases in Caffeine windows. Instances of Tweet bundle up the text and metadata of tweets. For the implementation, clear your browser’s cache for caffeine.js.org (including IndexedDB), and reload https://caffeine.js.org/.

I’m also running a node-livecoding server injected with turtle-graphics tweetcoding code, at wss://frankfurt.demo.blackpagedigital.com:8087/. Once you get connected (and tweets are flowing), you might see something like this:

After developing this system, I’ve realized I don’t really need to run SqueakJS from within NodeJS; just injecting code into it is fine. There are many possibilities here. :)

Have fun, and please let me know what you think!

Share this: Facebook

Twitter

Reddit

Flattr

Like this: Like Loading... Related