Polyglot is the ability to execute vRO scripts in multiple languages and runtimes, specifically Node.js, Python and PowerShell / PowerCLI. Now we can finally write JavaScript using modern constructs such as let/const, arrow functions, Promises, async/await, etc. Or the ones that prefer Python or PowerShell can finally put JS aside. Really nice stuff, but we can do a lot more…

So, did vRO really deliver this huge amount of integrations? Well, not directly, but as with the plugin mechanism in vRO, the multi language feature enables power users of the platform to write their own extensions and integrations. And in my opinion, it is much easier. Why? For one, you don’t need to learn the specifics of vRO, the script integration layer is so thin, that you can bring your already written scripts very easily. For another, whether it will be forums, blogs or publicly available modules, you have an enormous community support of those languages. Say you want to integrate with some AWS service, e.g. S3. What would you do if you don’t have a plugin for that? Just google it “How to Upload a file to Amazon S3 with Node.js” You will find hundreds of hits. All of those basically tell you how to download the AWS SDK and provide samples with couple of lines of code. What about Azure and Cosmos DB? Same thing – Node.js with Azure Cosmos DB! And the list goes on and on for the hundreds of thousands of Node (npm), Python (PyPI), PowerShell (PSGallery) and in house developed packages and modules, all at your disposal. You can use the tools of the ecosystem, develop and test how you are used to and once ready, import it in vRO.

As it shifts a bit from the traditional vRO script (ECMAScript 5.1), I have prepared a GitHub repository with template-like samples to make it easier for developers to start using and extending, feel free to clone it and provide feedback!

Happy (Java|Python|PowerShell)Scripting!

So in Lambda, let’s have our function defined as

exports.myHandler = function(event, context) {
  console.log("Event: " + JSON.stringify(event))
  return 'this is the result';
}

File: myIndex.js

When requested to run this function in the Node.js runtime, node is invoked. But is it called directly on your function? No, there is wrapped that deals with the internals of Lambda.

Very roughly this wrapper does something like

...
// somewhere we construct event and context

const task = require('./task/myIndex');
const result = task.myHandler(event, context);
...

File: wrapper.js

OK, but Lambda allows me to name my file and my handler anyway I like, how is this handled? This is where the handler property comes in hand. It is a property on the function definition that is used to specify the

The module-name.export value in your function. For example, “index.handler” calls exports.handler in index.js

In our example, our handler should be “myIndex.myHandler”.

And how would the wrapping code handle any handler names –

...
// somewhere we construct event and context

const [fileName, handlerName] = handler.split('.');
// i.e. fileName = handler.split('.')[0]; handlerName = handler.split('.')[1];
const task = require('./task/' + fileName);
const result = task[handlerName](event, context);
...

File: wrapper.js

That is nice, but what is even nicer is that Lambda allows us to define our function in three main formats:

1. Synchronous function that returns the result directly

exports.myHandler = function(event, context) {
  return 'this is the result';
}

2. Synchronous/Asynchronous function that returns a promise

exports.myHandler = function(event, context) {
  return new Promise((res, rej) => {
    // do any asynchronous operations if needed...
    res('this is the result');
  });
}

also

exports.myHandler = async function(event, context) {
  // do any asynchronous operations if needed...
  return 'this is the result';
}

3. Synchronous/Asynchronous function that uses a callback

exports.myHandler = async function(event, context, callback) {
  // do any asynchronous operations if needed...
  // first argument is for error if any
  callback(null, 'this is the result');
}

All of those are covered in detail in AWS Lambda Function Handler in Node.js
That is really nice because it allows for different coding styles, not enforcing any single once specifically.  And it is quite easy to handle, to be honest:

...
// somewhere we construct event and context
// somewhere we define how the wrapper treats the results and errors via a callback

const [fileName, handlerName] = handler.split('.');
// i.e. fileName = handler.split('.')[0]; handlerName = handler.split('.')[1];
const task = require('./task/' + fileName);
const result = task[handlerName](event, context, callback);

if (result) {
  if (isPromise(result)) {
     // case 2.
     // the result is a promise, i.e. an object with a function then and/or catch
     result.then(res => callback(null, res)).catch(err => callback(err));
  } else {
    // case 1.
    // the result from the synchronous function invocation
    callback(null, result);
  }
} else {
  // case 3
  // the passed callback as a third optional argument will be used when the function is ready to return the result/error
}

File: wrapper.js

Of course there are also other interesting things like how the event and context are constructed, how the result and error are processed. In this post we have covered only the actual function invocation.

Note that actual implementation used by Lambda may be different as this is based only on my findings from some reverse engineering/imagination.

I am very curious how this will turn out, will the GUI fit as a nice addition to the VUI of Alexa, or will it be too much of overhead for the Alexa users. Time will tell.

To give more insights I am starting to write up integration tutorials. By popular demand of Good Vibe’s users we are starting with Dropbox and iTextPad

Can’t wait to see what other uses people will find!

Word Chain is a game where players take turns in coming up with words, from a specific category, that begin with the letter that the previous word ended. It’s a fun way to build up and refresh your vocabulary.

Alexa can be a referee, validating the words are correct and not used, and it can be a fully qualified player that can play with us to build the longest word chain, or competing with us, depending on the mode.

The whole skill was really fun to implement. The stuff are typical programming 101 and string manipulation algorithms. Most effort I have spent on making the word selection picking more smart, meaning that Alexa will try to select such words so that the next player is left with enough choices that can continue the game in a direction that will last longer and build a longer word chain. So I think this is where the game shines.

In case you want to try it out, here are links to it:

https://www.amazon.com/tgeorgiev-Word-Chain/dp/B071RT4ZCZ (for the US store)
https://www.amazon.co.uk/tgeorgiev-Word-Chain/dp/B071RT4ZCZ (for the UK store)