I’ve published over a dozen Alexa skills over the last few years. I have run across several patterns and best practices in that time.

One of the more powerful but under-hyped features of the SDK that I’ve made extensive use of in my code is the Response Interceptor. It is part of the Alexa Node SDK. This SDK simplifies Alexa skill development.

When using it you may find your code getting messy with redundant error handling and clean-up tasks. Response interceptors allow you to insert a hook into the flow of handling Alexa intents. This keeps your code clean by performing last-minute actions in one central location before passing the response back to Alexa. This is extremely useful for debugging, resolving common tasks, and generally cleaning up responses to avoid some common errors encountered when using the Alexa ecosystem.

Debugging

To add a response interceptor with the Alexa SDK, you pass a class that implements a process function to the addResponseInterceptors function on your SkillBuilder object as shown in the code sample below. We’ll get to the implementation details of this class in a moment.

This snippet also shows setting a request interceptor function which will run before a request is passed to your Alexa handlers. For example, I find it helps debugging to log each incoming request and the outgoing response. You can do this with the request interceptor and response interceptor as demonstrated in this code snippet. The snippet also shows the syntax for the process function returning an empty Promise.

Resolving Common Tasks

Many of my skills process AMAZON.RepeatIntent so the user can re-hear the last response. If you have a complex skill, especially one that maintains state engines, you should provide additional detail when the user asks Alexa to repeat herself so the user knows exactly where they are. But in simpler skills, it’s fine to just replay the previous response back to the user. A response interceptor allows you to save each outgoing speech and reprompt cue so that you can re-play them easily:

Another common task is handling attributes. The Alexa SDK has several layers of attributes.

• request attributes (only good during a single request)
• session attributes (good for the length of a session)
• persistent attributes (saved in a store like DynamoDB to be used across sessions).

I find juggling all of these can be overwhelming. I structured my code to only use session attributes, which I save to persistent storage at the end of the session. But there are two problems with this as a blanket approach — there are attributes that you may not want to save and there are times you want a value to pass between handlers but not across the session (what request attributes aim to solve).

I get around these problems by using a session and request object off my attributes. You can see an example of the session field in the above code snippet saving lastResponse and lastReprompt. I don’t want to save these persistently, so I clear this entire object before persisting to storage at the end of the session. In a similar fashion, I clear the request object each time at the end of my response interceptor, so those attributes truly remain request-only.

Avoiding Common Errors

One of the limitations that plague many developers is that responses can’t contain more than 5 audio tags. Sometimes it can be difficult to avoid this with dynamic content.

For example in my Blackjack skill, I play a sound for each card that is dealt. Normally not a problem. But when reading out the dealer’s hand, if they end up drawing several cards you can go over this limit. Sure, I could try to catch this when I’m generating the response, but that convolutes the code. Who’s to say whether it hits every edge case?

Far better to remove the excess sound effects as part of the response handler. For this skill, I just remove excess audio files from the end of the response to get the count down to 5.

Another problem that I’ve encountered is that you aren’t allowed to return directives along with the Dialog.Delegate directive if you are eliciting slots from the user. This can be annoying if you are handling button input or using display directives. You might have to check in multiple places before adding directives to your response to make sure you don’t clash with the Dialog.Delegate. Keep your code clean and use a responseInterceptor to filter through your directives before returning instead:

I hope you enjoyed these tips and see the power of using response interceptors. Let me know your own best practices and share your own tips in the comments section!

I’m a software engineer that has published more than twenty custom skills on the Alexa platform. I’ve been recognized as an Alexa Champion, and have won multiple hackathons using the technology. The following highlights how I built a custom video skill for the Echo Show using native Amazon technology.

The History of Video Consumption

Video broadcasting has been a successful medium for more than sixty years. Television sets dominated the entertainment industry for decades with broadcast signals beaming directly into living rooms. In 1990, Cable Television had reached 57% of US households. This rapidly expanded the variety of content consumed by viewers.

Live streaming officially began in 1995, but it wasn’t until 2007 that internet-based streaming began to use the standard HTTP protocol. Smartphones like the iPhone were added soon after using similar communication methods. With the push to mobile, smaller screens started gaining more of our time. YouTube has been a huge success during this phase, and now plays 5 billion videos a day.

In 2015, Amazon launched the first device controlled solely by a user’s voice. Voice platforms like Alexa rapidly added another device to the home, with an estimated 35 million already being used in the US. In 2017, Amazon officially launched their first version of Alexa with a screen, called the Echo Show. The new Amazon Fire TV devices also have Alexa built in, enabling streaming video to a flat screen display to be controlled by your voice.

The Echo Show initially included the capability to play videos from YouTube, but lately, Google and Amazon have been fighting about it’s availability. This impacted the popularity of the product given how big of a feature video playing was.

At the 2018 CES, multiple consumer electronics companies announced that they were launching a Google Home compatible device with a screen. This makes the voice market even more competitive. One solution to the YouTube compatibility challenge is to host video content directly on Amazon. The following describes how to create a custom skill for the Echo Show that does just that.

How to Create a Custom Video Skill on Alexa

Building your own video channel is surprisingly easy using Alexa and a handful of AWS services. Here is the architecture featuring a custom Alexa skill that packages content to play on an Echo Show. The AWS storage service (S3) stores the media, and streams it to the device based on instructions given by the custom skill.

Component Level Architecture for Custom Video Skill

Producing content for this is comparable to that required for a YouTube channel. The current version of the Echo Show (as well as the Echo Spot) have specifications around the media type to follow. For example, the video should use an mp4 extension and a standard H.264 compression format. The resolution of the video quality should be no greater than 1280x720 in pixel size. These constraints provide a high quality video stream on the Show’s seven inch display comparable to that of a HD video player.

Building the Custom Video Skill

Creating a video channel requires authoring a custom skill for Alexa and publishing it to the public skill store. There are a number of features needed for navigating the content in the channel and playing the videos. This section will cover these steps in detail. For a working example, try out the Piano Teacher skill that is already in the Alexa store. It is a skill that contains short videos with beginner lessons on how to play the piano, as well as note-by-note video instructions on how to play simple songs. Here is the repo that contains all the source code needed, as well as detailed instructions to configure and deploy.

There are three features required to make a video channel.

1 — Render a background image when the skill is initially launched. This establishes the channel’s brand.
2 — Build navigation controls to browse and select which video to play. This includes handling touch gestures on the Echo Show screen.
3 — Delegate control to the device to play a video once content is selected.

1 — Brand with a Background Image

To facilitate the building of custom video skills, Alexa provides a series of templates. I use the “BodyTemplate1” template to render the background image when the skill is first invoked. When generating the metadata within the Alexa Developer Console, check the second and third boxes on the global fields screen (Video App & Render Template).

Setting these attributes enables additional APIs within the custom skill. Additional standard intents are required to use the APIs. These are created when building the intent model in skills kit. They are as follows:

• AMAZON.NavigateSettingsIntent
• AMAZON.NextIntent
• AMAZON.PageDownIntent
• AMAZON.PageUpIntent
• AMAZON.PreviousIntent
• AMAZON.ScrollDownIntent
• AMAZON.ScrollLeftIntent
• AMAZON.ScrollRightIntent
• AMAZON.ScrollUpIntent

No coding in the Lambda function is required for these events, as the device will handle them natively. They just need to be included in your custom skills intent model.

Rendering a background image requires two utility methods that are already distributed in the standard Alexa SDK. The skill creates two identifiers to illustrate how they are used.

// utility methods for creating Image and TextField objects

const makePlainText = Alexa.utils.TextUtils.makePlainText;
const makeImage     = Alexa.utils.ImageUtils.makeImage;

Next, I add an identifier for the location of your jpg/png file that serves as the background image. This object needs to be publicly available. The pixel size is 1024x600 based on the dimensions of the Echo Show. You don’t need to provide a separate image for the smaller Echo Spot. Alexa creates the smaller image based on the original file sized for the Show.

// This is a public endpoint - the easiest way is to host in S3
// It needs to be SSL enabled (which S3 does for you)

const backgroundImage = ‘https://s3.amazonaws.com/.../image.jpg';

Next, add the following code to render the background image when the skill gets launched, along with any other audio messages.

‘LaunchRequest’: function () { 
  const builder = new Alexa.templateBuilders.BodyTemplate1Builder();
  const template = builder.setTitle(‘Your Personal Instructor’)
      .setBackgroundImage(makeImage(backgroundImage))
      .setTextContent(makePlainText(‘Piano Teacher’)) 
      .build();

  // check if the device has a video screen
  if (this.event.context.System.device.supportedInterfaces.Display){      
    this.response.speak(welcomeMessage)
        .listen(repeatWelcomeMessage).renderTemplate(template);
    this.emit(‘:responseReady’);
  } else {
    // handle error of not having a video screen to play
    this.emit(‘:tell’, nonVideoMessage);
  } 
},

2 — Content Navigation

The navigation for the content takes advantage of the flexibility of the Alexa platform. The viewer can use either their voice or fingers to navigate the content catalog, selecting exactly what they would like to view. This requires using the list template within the Alexa SDK, as well as handling events triggered from the user touching the screen.

Here are the different options that the user may request using either their voice or touching the screen.

Rendering a list of what content is available is central to the user experience. I use ‘ListTemplate1’ from the Alexa SDK to render the list of videos. Scrolling up and down can be done through either voice or touch, and is handled by the device with no coding required.

The response object that is sent to list the content contains an array listing what is available on the channel. In my skill, this list is read by the Alexa voice, and is rendered visually on the screen. Here is an example of what it looks like.

Screenshot of Piano Teacher Skill on an Alexa Show

Within the code, the content is externalized into an array object (songs.json) that contains a list of videos, as well as metadata about the location of each media file. Each item in the list has a unique token assigned. Here is a sample of the layout written in standard Javascript object notation:

[ 
  { “requestName”: “Silent Night”, 
    “listSong”:true, 
    “token”:”song001", 
    “difficulty”:”Moderate”, 
    “videoObject”: “SilentNight.mp4”, 
    “audioObject”: “SilentNight.mp3” 
  }, 
  { “requestName”: “Mary Had a Little Lamb”, 
    “listSong”:true, 
    “token”:”song002", 
    “difficulty”:”Easy”, 
    “videoObject”: “MaryHadLittleLamb.mp4”, 
    “audioObject”: “MaryHadLittleLamb.mp3” 
  },
...
]

Here is the code that converts the array into the response needed by Alexa. Included is embedding the token for each item in the array.

// these are the songs that recordings have been made for
var songs = require("data/songs.json");

// create List
const itemImage = null; 
const listItemBuilder = new Alexa.templateBuilders.ListItemBuilder(); 
const listTemplateBuilder = new Alexa.templateBuilders.ListTemplate1Builder();

// build an array of all available songs 
for (i = 0; i < songs.length; i++ ) { 
  if (songs[i].listSong) { 
    // pull attributes from song array and apply to the list
    listItemBuilder.addItem(null, songs[i].token,
      makePlainText(songs[i].requestName),
      makePlainText(songs[i].difficulty)); 
     message = message + songs[i].requestName + “, “;
  } 
} 
message = message + “Just select on the screen a song, or request by saying something “ + “like, Teach me how to play “ + songs[0].requestName + “.”;

// now create the response object using the SDK
const listItems = listItemBuilder.build(); 
const imageLoc = pianoStrings; 
const listTemplate = listTemplateBuilder.setToken(‘listToken’)
  .setTitle(‘Available Song List’) .setListItems(listItems)
  .setBackgroundImage(makeImage(imageLoc)) 
  .build(); this.response.speak(message).listen(noSongRepeatMessage).renderTemplate(listTemplate); 
this.emit(‘:responseReady’);

The Lambda function handles the ‘ElementSelected’ event invoked by the Echo Show. The request object sent by the device to the custom skill contains the token used to translate what was selected by the user.

// this function is invoked from the 'ElementSelected' event
‘ScreenSongSelected’: function() { 
  console.log(“Element Selected:” + this.event.request.token);
  var videoName = “”;
  // match token to song name and find the video object to play 
  for (i = 0; i < songs.length; i++ ) { 
    if (songs[i].token === this.event.request.token) { 
      console.log(“Play “ + songs[i].requestName);
      videoName = songs[i].videoObject;
    } 
  } 
  const videoClip = videoLoc + videoName;
  this.response.playVideo(videoClip); this.emit(‘:responseReady’); 
},

The Lambda function uses the token it receives and finds the media file corresponding to the unique identifier. Control is then transferred to the device with the appropriate video.

3 — Delegate Control to the Video Player

Once the video that needs to be played is found, the endpoint of the media is added to the response. This requires a few lines of code within the Lambda function.

First, identify a folder in the S3 bucket where the video files will be stored.

// These are the folders where the mp4 files are located

const videoLoc = ‘https://s3.amazonaws.com/…/media/';

Then specify the exact file based on what was identified by the user. Metadata is added that contains more information about the video.

if (this.event.context.System.device.supportedInterfaces.VideoApp) {
  const videoClip = videoLoc + videoObject; // endpoint of the file
  // this will be rendered when the user selects video controls
  const metadata = { 
    ‘title’: slots.SongName.value 
  };
  this.response.playVideo(videoClip, metadata);
  this.emit(':responseReady');
} else {
  // handle error - and close the session
  this.emit(‘:tell’, nonVideoMessage);
}

After this code executes, the Alexa device will take over navigation of playing the video. The user can either use their voice or touch the screen to pause, rewind, fast-forward, etc. Here is what the screen looks like when playing a video, including the Metadata title at the top.

Screen shot of Piano Teacher Skill on an Alexa Show

When the video playing on the device is complete, the skill can be used again to select more content.

Summary

Building the custom skill can be done using the example above as a template in just a few hours. The Alexa certification process takes just a day or two, then the skill (and content within it) will be available for anyone with an Echo Show. As a fan of YouTube, I hope to be able to use it on my Alexa device soon, but there’s also a way for content publishers to go around it.

Developing an Amazon Alexa skill within an AWS Lambda function is a simple way to demonstrate the power of ‘serverless’.

Within an hour, you can design, develop and deploy an Alexa skill onto the Amazon.com marketplace — with instant access to millions of consumers.

Over the past couple of years, I’ve developed a bunch of simple Alexa skills to experiment with AWS Lambda and explore the Alexa Skills Kit. Along the way, some of the skills have even generated enough customers to qualify for a monthly payout from Amazon’s incentive program.

The majority of the work involves coding an AWS Lambda function that expresses the business logic — using your choice of popular languages such as Node.js or Python. To get started, the Amazon Alexa team makes it really easy with a variety of sample templates in their GitHub repositories.

With much of the undifferentiated infrastructure heavy-lifting being done by AWS, you can focus attention on the actual product, marketing, and customer acquisition. For an Alexa skill, your results are easily measured by the volume of unique customers and their number of interactions.

Amazon Alexa metrics

During the month of December, several of my custom Alexa skills — which are all based on AWS Lambda functions running in a single account — have collectively reached over 100K users in just 30 days.

Below are the 30-day metrics for a few of these skills, including Merry Christmas and Santa Claus — and cloud computing cult favorite Simon Says. The data for each skill is accessible directly in the Alexa developer console.

AWS Lambda metrics

So how does a large volume of customers, sessions, and interactions translate to the underlying utilization of AWS Lambda functions?

Over the same 30-day period, the Alexa skills have invoked the related AWS Lambda functions over 1M times.

All the Lambda functions share the same AWS account —and each function is allocated 512MB of memory and configured with a 7 second timeout. If needed, AWS provides a lot more levers to prepare your Alexa skill for scale.

During the 30-day period, not a single function was throttled due to invocation rates exceeding the concurrency limits. The average invocation duration for the functions was 25 milliseconds.

The cost of serverless

How much does hosting a dozen Alexa skills that connect to over 100K unique users in 30 days with 1M function invocations cost? Zero. Zilch. Nada.

AWS provides developers access to 1M requests and 400,000 GB-seconds of compute time per month — at no cost. With the memory size of my functions set to 512MB, that equates to 800K free tier seconds per month.

Here’s the December invoice for my personal AWS account:

The only cost incurred during the same period was a whopping $0.02 — the high cost of experimenting with new AWS Kinesis Video Streams service.

So what happens if your Alexa skills go viral and exceed 1M requests for the AWS Lambda service? For every 1M requests thereafter, you’ll get a charge of $0.20 to your bill — easily absorbed by the $100 of promotional credits provided to Alexa developers.

The economics of serverless technology also applies to the most heavily used Alexa skills. For example — even with over 50 million Lambda requests serving 175K users per day, the sleep sound apps developed by Nick Schwab generates a frugal monthly bill under $30.

The value of frictionless innovation

Software engineers at leading startups and enterprises are deploying serverless architectures to convert innovative product ideas into consumable value — with minimal friction and negligible cost.

Serverless technologies like AWS Lambda functions are key enablers of frictionless innovation — allowing you to more easily deploy and scale products and services into the hands of a global customer base.

Despite the clear business advantages, there still seems to be a lot of debate and fear-mongering regarding the value of adopting serverless technology. Don’t believe the FUD — fear, uncertainty and doubt.

As the abstraction of platform services matures with serverless, the elimination of utility layers can move you closer to the customer experience — and closer to the functional value of technology.

Drew is an AWS Community Hero, Alexa Champion, and maker of dad jokes.
Follow on Twitter @drewfirment. #WePowerTech

Happy Christmas to all, and to all a good night!

Inspired by the holiday season, emerging voice-first technology, and too much eggnog — I’ve twisted the classic poem from Clement Clarke Moore into a modern Christmas tale.

My holiday wish is that a few developers are inspired to build their own Alexa skills and fill my Amazon Echo with cool custom skills in 2018. I hope you find this fun and filled with holiday cheer.

‘Twas the night before Christmas,
when all through the hills
Not an Alexa was stirring,
not even 5,000 cat skills;

The Echos were connected
to wi-fi with care,
In hopes that new features
soon would be there;

The devs were nestled
all snug it their beds;
While visions of incentives
danced in their heads;

And Bezos in his rocket,
and AWS on the map,
Had just fried our brains
with their re:Invent rap.

When out from Alexa
there arose such a clatter,
I sprang from my bed
to listen to her chatter.

Away to the device
I flew like a flash,
Tripping over my Dot
and programmable dash.

The screen from my
brand new Echo Show,
Gave a lustre of midday
to devices below.

When what to my
developer eyes did appear,
But a miniature Spot
and eight Alexa pioneers.

With Alexa evangelists
so lively and quick,
I knew in a moment
he must be St. Nick.

More rapid than Lambda
his skills they came,
And he whistled, and shouted,
and invoked them by name:

“Now, Song Quiz! now, Rain Sounds!
now Flash Briefings and Jeopardy!
On, Beer Bot! on, Potterhead Quiz!
on, Mystic Mirror and Inspire Me!

To the top of the search!
to the top of Amazon’s leader wall!
Now invoke away! invoke away!
invoke away all!”

As keyboards that before
the developers fly,
When meet with an error,
give another try;

So up to the rankings
the Alexa skills they flew
With the sleigh full of Echos,
and St. Nicholas too —

And then, in an utterance,
I heard on the speaker,
The slots and intents
of each new feature.

As I drew in my ear,
and was turning around,
Down the dev portal
St. Nicholas came with a bound.

He was dressed as Alexa,
from his head to his foot,
And his woofer was covered
with sound files and aux input;

A bundle of devices
he had flung on his back,
And he looked like a developer
getting approval feedback.

His LEDs — how they twinkled!
his light ring, how merry!
His Dolby was crisp,
his smart home integration legendary!

His seven microphones
picked up all the audio,
And the wake words
were as clear as the snow;

The stump of a cord
he held tight in his base,
And the notifications,
it encircled his head with grace;

He had hand-free calling
and a little cylinder belly,
That replied when invoked,
like a clerk at a deli.

He was quick and responsive,
a right jolly old elf,
And I said “Alexa!” when I saw him,
in spite of myself;

A wink of his lights
and a twist of his top,
Soon gave me to know
I had nothing to stop;

He spoke so many words,
putting SSML to work,
And filled all the rooms;
it gave me a smirk.

And connecting to the cloud
with his API,
And giving a nod,
Alexa said goodbye;

He sprang to his sleigh,
to evangelists gave a whistle,
And away they all flew
like a Blue Origin missile.

But I heard Alexa exclaim,
ere he drove out of sight —
“Happy Christmas to all,
and to all a good night!”

Merry Christmas!

Here’s an article I wrote about If you want to learn more about Alexa skill development — and how it’s a great gateway to cloud computing. Then be sure to enable the Santa Claus skill to see if you’ve been naughty or nice!

Why learning to code Alexa Skills is the gateway to a cloud computing job
_There are radical economic shifts underway. Society is moving from commodity-based capital toward intellectual capital…_medium.freecodecamp.orgNaughty or Nice?
_Naughty or Nice? — Santa Claus is making a list and checking it twice! Do you want to know if you are naughty or nice…_devpost.com

AWS Community Hero, Alexa Champion, and maker of dad jokes.
Follow me on Twitter @drewfirment. #WePowerTech

I’m both a sports nut and a software engineer. I’m also recognized as an Amazon Alexa Champion. I continue to look for new ways to stretch this technology.

Over the past two years, I’ve won hackathons for skills on the Alexa platform.

Skills are the part of the Alexa voice service that activates its capabilities. In Alexa, skill is a term used for capabilities that make an experience more personal. You can enable or disable them as you choose. And, with the Alexa Skills Kit, You can create and customize them.

Sports games are an enormous market

Video games are a huge market, with annual revenues projected at more than $100B worldwide. Shooter and action games are the most popular, followed by sports games.

Voice platforms are growing at a fantastic rate. The popular Amazon Alexa platform has grown by 4 times in the past year. There are now 20,000 custom skills on the Alexa platform. Yet no sports games are more complex than calling out trivia.

Here is a sample of my new football game called End Zone Football. This shows how an advanced game can work on the Alexa platform.

Begin game design with Storyboards

Designing the skill requires writing storyboards to script the action. Start with how the game will begin. Then write the narrative for basic gameplay.

Consider yourself to be a playwright or a movie director. Ask yourself: What should the native Alexa voice say? What sounds can be played that are part of the game?

Here’s what I learned from publishing a Baseball and Football game on Alexa. These tips will improve the usability of your game:

• Keep the interaction simple
  yes or no and 1/2/3/4 answers work best
• Identify sounds that can make the gameplay more exciting
  Crowd cheering, whistles, or the crack of a bat
• Simplify the game
  The Baseball game skills should include foul balls
  The Football game skills should simulate penalties
  These help keep the user engaged
• Don’t rely on visuals
  A background image for the Echo Show is nice, but the images on the companion app should be secondary
• Bound the game to 2–5 minutes
  Users can play again and again if they have time
• Create a help function that explains the game in detail
  Give examples of phrases to use to play
• Above all else
  Make it Fun!

Learn SSML to include sounds with voice

Speech Synthesis Markup Language (SSML) integrates sound with voice. It’s used to create the audio for the Alexa device.

This is how I set the main response attribute to call the Alexa API. After splicing the strings in JavaScript, the code looks like this:

var speechOutput = “Welcome to End Zone Football. “ +   “<audio src=\”” + bucketLoc + “BandMusicIntro.mp3\” />” +  “The game that lets you drive the “ +   “ball down the field using just your voice. “ +   “<break time=\”1s\”/>” +   “You are in charge of the Blackbears, and are down “ +  sessionAttributes.away + “ to “ + sessionAttributes.home + “. “ +   “<break time=\”1s\”/>” + “The ball is on the “ +   yardline + “ yardline. “ +   “When you are ready, just call out the play you want to run, and the game will begin. “ +   “For a list of plays at anytime say, Read Playbook. “;

Here are some examples of how to use SSML in this context:

• To create a pause
• To insert a soundclip
  <audio src=”https://s3.amazonaws.../file.mp3">

I recommend using an S3 bucket to store the media files. This is a low-cost way of storing data. And they can be accessible to Alexa.

State management tracks the progress of play

Alexa has the ability to store the gameplay state. Use this feature to simplify the coding and testing of your skill.

In the Node.js SDK, a session attribute is passed with the request and response attributes. You can use the session attribute for the gameplay state. Store critical game information in this field. You can include anything, like the play number or recorded number of outs.

Here is an example used in the Football game

// save the game attributes through to the next play    if (session.attributes) {          sessionAttributes = session.attributes;    }...

// gameplay rules for passingif (offensivePlaybook[i].playType === “pass” &&    offensivePlaybook[i].playNumber.toString() ===     intent.slots.playNumber.value) {       console.log(“Matched Play Number”);       // calculate pass distance based on play selected      passDistance = Math.round(Math.random() *         (offensivePlaybook[i].maxYardage            — offensivePlaybook[i].minYardage)            + offensivePlaybook[i].minYardage);       // make sure distance of play can’t be longer than       // the remaining field       if (passDistance > sessionAttributes.yardline) {         passDistance = sessionAttributes.yardline;       }       playDesc = offensivePlaybook[i].playDesc;       speechOutput = speechOutput + playDesc + “. “;       // based on the play selected, determine relative       // completion rate       passCompletion = offensivePlaybook[i].completionRate;)...// pass back the response to Alexa, and save the gamestatecallback(sessionAttributes,                 buildSpeechletResponse(cardTitle, speechOutput,       cardOutput, repromptText, device, shouldEndSession));

Storing this data in a table for analytics is helpful, but is not needed in an initial version. Let the Alexa platform do this work for you.

Advertise your skill on social media

People don’t yet realize all the things that an Alexa can do. When doing demos of these skills, I consistently get feedback that “I didn’t think Alexa could do that.”

All skills must be certified before publication on the Amazon Store. When your skill passes the certification process, take the time to record a video of it in action. It is the best way to prove what the platform is capable of.

Thank you for reading, and please enjoy these games — they’re free!

It’s been a year since I began learning to code. I became interested in coding because of my desire to work with others in the beauty, fashion and luxury lifestyle world. I wanted to create amazing websites with animated elements and other digital media.

I started with an online course and a month later, I discovered freeCodeCamp. That’s when learning to code became more exciting and insightful.

There is real-time communication with fellow coders ready to help you work through interactive challenges. They provide feedback and references for further learning. This helped my confidence grow and coding skills improve.

In early June, a friend told me about an online webinar titled “Build Voice Enabled Experiences with Amazon Alexa.” The idea of the webinar increased my curiosity because at the time, I had only seen commercials, but had not used an Alexa enabled product. I signed up and was fascinated.

At the end of the webinar attendees received information about a promotion. If within 30 days you created a Skill and got it published, you were eligible to win a free Echo Dot. I didn’t know if I had enough knowledge to succeed, but I decided to give it a try to learn.

The thought of creating my first app was exciting. At that moment, my Alexa learning experience began.

Amazon Alexa Enabled Devices

What is Alexa and how does it work?

Alexa is a cloud-based voice service that powers millions of voice experiences in the home. Devices Alexa powers includes Amazon Echo, Echo Dot, Amazon Tap and Amazon Fire TV.

A Skill is a voice-driven application for Alexa.

Alexa provides “Skills”, which allows users to interact with the devices. Skills can be created to do many things. They can answer questions, play trivia games, play music, set an alarms, tell jokes and more.

The Alexa Skills Kit (ASK) is a collection of tools, API’s, documentation, code samples and templates with links to GitHub. The ASK helps developers create Skills for Alexa enabled devices.

An Alexa Skill has two main components: a Skill Service and a Skill Interface.

Your code is written in Node.js for the Skill Service which lives in the Cloud (Amazon AWS, Lambda, an HTTPS service). It receives instructions to determine the actions to take in response to the user requests from the Alexa enabled device.

The Skill Service implements event handlers that define how the Skill will behave. The event is triggered when the user speaks into an Alexa enabled device.

Then you configure the Skill Interface with the Skill Developer Portal. The interface processes the users’ words to trigger the events that the Skill Service handles. In this area you determine what to call your Skill so the user can invoke it by name. This also is where you define the Skill interaction model. This is so it knows how to listen to users’ spoken words and respond with the information intended.

It’s the interaction of the two components that make the Skill work.

The Amazon Team provided links to three Skill Templates. These templates are great to help you get started and to learn how Alexa interacts and responds.

• Fact Skill template
  to create something like a “fact” or “joke” of the day.
• Decision Tree template
  to create simple adventure games and quizzes
• How To template
  to create skills like recipes content with similar step by step processes.

Plus many more intermediate and advanced templates available .

My first published Alexa Skill, Makeup Facts

I now have three published skills, Makeup Facts, Fashion Facts and Girls Can Code . I work as a freelance makeup artist and fashion stylist and decided to start with what I know best.

To create these “Fact Skills” I reviewed the topic and information on creating a Skill. Then I created my list of facts that would be integrated into the Fact Skill Template. All Skills were accepted and published within a couple of days.

How I created my first Skill

Go to Amazon Developer Portal sign in, click Alexa at top of the screen.

Amazon Developer Console

On the Alexa page, choose the “Get Started” for the Alexa Skills Kit.

Alexa Skills Kit get started button

On the next page..select “Add New Skill.”

from Amazon Alexa Skill Kit Tutorial

Then fill out the Information page.

Skill Type: Custom

Language: English

Name: Makeup Facts

Invocation Name: (what your user will need to say to start the Skill) Makeup Facts

my Skill information page

Click next to go to Interaction Model page. This is where you create intents or what users will ask Alexa to do. Then create utterances or possible ways the user will ask Alexa about the Skill you’ve created. I found this GitHub repository to be helpful. The Samples include: give me a fact, tell me a fact.

from Alexacourse GitHub

My Intents in the Interactive Model for Makeup Facts

{ “intents”: [ { “intent”: “GetNewFactIntent” }, { “intent”: “AMAZON.HelpIntent” }, { “intent”: “AMAZON.StopIntent” }, { “intent”: “AMAZON.CancelIntent” } ] }

My Utterances in the Interactive Model for Makeup Facts.

GetNewFactIntent a factGetNewFactIntent tell me a factGetNewFactIntent tell me a makeup factGetNewFactIntent give me a factGetNewFactIntent give me a makeup factGetNewFactIntent tell me triviaGetNewFactIntent give me triviaGetNewFactIntent give me some informationGetNewFactIntent tell me somethingGetNewFactIntent give me something

Now it’s time to set up Lambda. Go to https://aws.amazon.com/ and sign into the console. Then go to services-Lambda.

from Amazon Alexa Skill Kit Tutorial

On the top right of your page, make sure your AWS Region is N. Virginia.

from Amazon Alexa Skill Kit Tutorial

Then click the blue button to create a Lamda function.

Choose the blueprint that looks like this:

from Amazon Alexa Skill Kit Tutorial

Configure your trigger. Make sure you choose Alexa Skills Kit in the drop down menu.

from Amazon Alexa Skill Kit Tutorial

Configure your function. Make sure your function name is written in camelBack. You can leave the description blank, but you are building this in Node.js.

Add your updated code.

There is an AlexaSkill.js file written with specific event handlers. It specifies output, prompt and speech. There is also an Index.js file that you customize to meet the needs of your Skill.

Girls Can Code (index.js)

‘use strict’;var Alexa = require(‘alexa-sdk’);

var APP_ID = “amzn1.ask.skill.1f2c85a9-b1b6–49a8-b94d-8a795d545d98”;

var SKILL_NAME = “Girls Can Code”;var GET_FACT_MESSAGE = “Here’s your fact: “;var HELP_MESSAGE = “You can say tell me a code fact, or, you can say exit… What can I help you with?”;var HELP_REPROMPT = “What can I help you with?”;var STOP_MESSAGE = “Goodbye!”;

var data = [ “Coding is awesome.”, “You can create tools that will change the world.”, “Coding is creative.”, “Coding is like solving a puzzle.”, “Coding work can be done remotely”, “Learning code is empowering.”, “Technology and coding help create the future.”, “Girls who can code have the edge”, “Anyone can code. You’ll discover something new.”, “Coding promotes critical thinking”, “Women make great coders”, “Girls who code are role models for all women.”, “Girls who code know that technology is not just for boys.”, “Jobs in tech are in demand.”, “Coding is the language of the 21st century”, “Girls who code help close the gender gap.”, “Coding can be done anywhere, anytime”, “Working in tech can be a very lucrative career choice”, “Coding is not just about building robots and website, you learn to create things that don’t exist”, “A girl who codes could create the next new social media app”, “A girl with tech skills can change the ways businesses communicate”, “Girls who code love to learn.”];

exports.handler = function(event, context, callback) { var alexa = Alexa.handler(event, context); alexa.APP_ID = APP_ID; alexa.registerHandlers(handlers); alexa.execute();};

var handlers = { ‘LaunchRequest’: function () { this.emit(‘GetNewFactIntent’); }, ‘GetNewFactIntent’: function () { var factArr = data; var factIndex = Math.floor(Math.random() * factArr.length); var randomFact = factArr[factIndex]; var speechOutput = GET_FACT_MESSAGE + randomFact; this.emit(‘:tellWithCard’, speechOutput, SKILL_NAME, randomFact) }, ‘AMAZON.HelpIntent’: function () { var speechOutput = HELP_MESSAGE; var reprompt = HELP_REPROMPT; this.emit(‘:ask’, speechOutput, reprompt); }, ‘AMAZON.CancelIntent’: function () { this.emit(‘:tell’, STOP_MESSAGE); }, ‘AMAZON.StopIntent’: function () { this.emit(‘:tell’, STOP_MESSAGE); }};

Create a compressed file with the above two files and upload the zipfile into Lambda.

Skip the Advanced settings.

Copy the ARN # in the top right hand corner of your screen.

from Amazon Alexa Skill Kit Tutorial

Go back to the Amazon Developer page. Select your skill and click on the Configuration tab located in the left sidebar menu.

Select the AWS Lambda option. Check the North America box. Paste the arn# that you copied from your Lambda dashboard.

my configuration page

Test your Skill. If necessary, update it so that it works properly. This GitHub Repository gives you the sample code for creating a Fact Skill. Check it, clone it and update it to write your own.

You can test your code in the Developer Console, in the Lambda functions, on your Echo and at Echoism.io.

Enter your Publishing and Privacy information.

Congrats..you’re ready to submit for certification.

It takes a few days to hear back from the Amazon Developer Team. If your Skill is approved, then everything works and all of the information is compliant. Your Skill will be certified and published and available for others to use.

If not, you will receive feedback and suggestions on what you need to to to resolve any issues so you can re-submit.

My 2nd published Alexa Skill, Fashion Facts

What I learned

• It’s helpful to have some familiarity with JavaScript and Node.js.
• You will need an AWS (Amazon Web Services) account and an Amazon Developer Account to complete and submit Skills.
• Review the words you cannot use that will conflict with how Alexa responds.
• Listen to the preview of your Skill. It’s extremely helpful to know your information flows.
• It’s very different creating something that is voice activated by an end user as compared to reading on a screen.
• Pretend you are the end user when writing your Skill. It helped me understand how the user would ask Alexa for information.
• If your Skill is not accepted review the feedback from the Alexa Skills Team. They provide great information that will help you get your skill certification ready.
• If you provide improvements to one of your existing Skills, the improved Skill has to go through the same process.
• You need an icon or image for your Skill to upload with submission.
• Once your skill is accepted and certified, it is live on Amazon.

I am currently working on two Skills. One uses the “Decision Tree template” and the other uses the “How To template”. These are a little more complex to build, but I’m confident will have them published soon.

I also have my free Echo Dot. Interacting with this device has given me ideas for developing more Skills.

My 3rd published Alexa Skill, Girls Can Code

When you’re building Lambda functions, it’s easy to get trapped in an “Invalid ELF header” nightmare. The problem is that your binaries are built for the wrong platform. Here’s what’s going on, and how you can fix it easily using Docker.

When most people get started with Lambda functions, they’ll use the online editor in the console to input their code. This is fine for your first example or two, but pretty soon you’ll want to do something wild and crazy like, y’know, import a library.

Over the past few weekends I’ve been working on my first Alexa skill for an Amazon Echo and I’ve reached that point where I want to use some third party code to add some additional functionality.

Your options for supplying the code for your Lambda function, as seen in the AWS Console

The online editor simply lets you edit a single file. If you want to refer to other files — including imported libraries — you can upload them in a ZIP file (Amazon call this a deployment package). But if you‘re working on a Mac or a Windows computer, there’s a catch.

When you use pip to install Python libraries on your laptop, it gives you binaries (.so files) that are built to run on your machine. But when the Lambda function runs in the AWS cloud it is going to be running on Linux — and binaries built for Mac (these are often called ‘darwin’ builds) or Windows won’t run on Linux (and vice versa).

If you upload the Mac version, you’ll see “invalid ELF header” logs when you try to test your Lambda function.

Invalid ELF header indicates it’s the wrong binary format for the platform

So you’re going to need Linux versions of those library files. But what if you don’t have a Linux box to hand?

You could grab yourself an EC2 instance from Amazon (or a droplet on Digital Ocean, or any Linux VM of your preference) but to my mind that’s quite a performance, and could even cost you a little bit of money (especially if you forget to take the EC2 box down again when you don’t need it).

I think the easiest solution is to use Docker.

The Docker approach

With Docker you can very easily can run a Linux container locally on your Mac, install the Python libraries within the container so they are automatically in the right Linux format, and zip up the files ready to upload to AWS. You’ll need Docker for Mac (or Windows) installed first.

Spin up an Ubuntu container that can see the Lambda code you want to upload.

docker run -v <directory with your code>:/working -it --rm ubuntu

• The -vflag makes your code directory available inside the container in a directory called “working”.
• The -itflag means you get to interact with this container.
• The --rm flag means Docker will remove the container when you’re finished.
• ubuntu is the name of an official container image containing, you guessed it, Ubuntu. If this container image isn’t already on your machine, Docker will download it for you.

You should now be inside the container at a shell prompt looking something like this:

root@c1996f32a397:/#

Install pip and zip:

$ apt-get update$ apt-get install python-pip$ apt-get install zip

Move into the working directory (you should be able to see your Lambda function code here):

$ cd working

Use pip to get the library/ies you’re interested in. You can use the -t flag to tell pip to put the libraries here in the current directory, which will be more convenient later as it’s where the AWS deployment package wants them to be:

$ pip install -t . <library>

If you’re very curious, you can take a look to see what this installs. In my own case I installed the editdistance library, which gave me the following additional directories and files.

editdistance:__init__.py __init__.pyc _editdistance.h bycython.so def.h

editdistance-0.3.1.dist-info:DESCRIPTION.rst INSTALLER METADATA RECORD WHEEL metadata.json top_level.txt

You can see that bycython.so file? This is the correct, Linux version of the binary that AWS was objecting to when I hit the Invalid ELF header (shown in the error log screenshot above).

Create the ZIP file with your Lambda code (in my case, a single file called lambda_function.py) and the libraries (for me, the two editdistance directories and their contents.

$ zip linux-lambda.zip lambda_function.py

$ zip -r linux-lambda.zip edit*

The -r flag on zip tells it to recursively add the contents of directories.

Now you have an archive file called linux-lambda.zip which is ready to upload to AWS. And because the directory is mounted from the host (your Mac) into the container, you can simply upload the file into the console.

Back in the terminal type exit to quit the container, and it will be as if it never existed, except for the existence of the linux-lambda.zip file, which is still available on the host.

Upload the ZIP file in the console, save it and try running a test. Invalid ELF header error no more!

If this article helps you out, please hit the ? button to make it easier for other people to find it. If you really like it, why not go bananas and share it too?

I’ve written a few other posts about what I’m learning as I write my first Alexa skill, like this one where I add database storage capabilities to my Lambda function. If you find them useful, you might be interested in a book I’m writing called Adventures with Alexa. Pick your own price!

How to use Swift to develop custom skills for the Amazon Echo

The Alexa Voice Service is Amazon’s cloud service that understands natural language and allows users to interact with devices by using their voice. You usually associate Alexa with Amazon’s voice-enabled speakers, such as the Echo, but Alexa can potentially run on any connected device with a microphone and a speaker.

Unlike Apple’s Siri, whose extensions are limited to specific domains, Alexa’s API enables developers to implement a broad range of custom voice services called “skills.” Using Swift allows iOS developers (like me) to expand their existing skill set to include server-side programming and take part in the trend towards voice user interfaces.

Ingredients

Simply put, Alexa sends your skill a JSON message with the user’s intent and your code answers with a JSON message that determines what Alexa will answer to the user.

Since I prefer to implement this functionality in Swift, I use AlexaSkillsKit, a Swift library that I wrote. It takes care of parsing JSON requests from Amazon, generating the proper responses and providing convenience methods to handle Alexa features.

The code for your custom skill can run as either a stand-alone web service or an AWS Lambda function. Using Lambda, Amazon’s serverless computing platform, Amazon will take care of scaling and running your Swift code — this is the reason I’ll use this deployment type for the finished skill. As you’ll see, however, the web service option is really useful while developing your skill.

Note that out of the box, Lambda only supports code written in JavaScript (Node.js), Python, and Java. But it’s easy to extend this to executables written in any programming language you want. My article Serverless Swift provides a step-by-step guide on how to do this.

To summarize, you’ll need the following for your Alexa skill:

• An implementation of your skill’s functionality in Swift using AlexaSkillsKit
• A Lambda function set up with your Swift code using the AWS Console
• An Alexa Skill configured in the Alexa Console that triggers your Lambda function

Note that the Alexa Console and the AWS Console are two separate services that you need to sign up for.

The Sample Project

To simplify your first steps, I created a repo with a sample app. swift-lambda-app contains code and scripts to quickly get you started with writing a custom Alexa skill in Swift and deploying it to AWS Lambda.

The sample app uses a standard Swift Package Manager directory layout and package file thus swift build, swift test and swift package generate-xcodeproj work as expected. Check out the SPM documentation for more info.

There are three targets:

• AlexaSkill: this is a library with the code that implements the custom Alexa skill. It’s a separate library so it can be used by the other two targets. Also, libraries have ENABLE_TESTABILITY enabled by default which allows you to access internal methods and properties in your unit tests.
• Lambda: The command line executable for deployment to Lambda. This program uses stdin and stdout for processing data.
• Server (macOS only): To simplify implementing a custom Alexa Skill, the server provides an HTTP interface to the AlexaSkill target. This HTTP server can be exposed publicly via ngrok and configured in the Alexa console, which enables you to develop and debug an Alexa skill with code running on your development computer. This target is macOS only because it wasn’t possible to cleanly separate target dependencies and I didn’t want to link libraries intended for server development to the Lambda executable used for deployment.

For development, I recommend a Test-driven Development approach against the library target, because this results in the quickest turnaround for code changes. Uploading to Lambda to quickly verify changes isn’t really an option because of slow uploading times. Exposing your functionality via HTTPS as described below, however, enables you to test and debug your functionality in a slightly different way.

Implementing a Custom Alexa Skill

Start with implementing the RequestHandler protocol. AlexaSkillsKit parses requests from Alexa and passes the data on to methods required by this protocol.

public protocol RequestHandler {        func handleLaunch(request: LaunchRequest, session: Session, next: @escaping (StandardResult) -> ())

    func handleIntent(request: IntentRequest, session: Session, next: @escaping (StandardResult) -> ())

    func handleSessionEnded(request: SessionEndedRequest, session: Session, next: @escaping (VoidResult) -> ())}

For example, a launch request would result in AlexaSkillsKit calling the handleLaunch() method.

import Foundationimport AlexaSkillsKit

public class AlexaSkillHandler : RequestHandler {    public init() {}    public func handleLaunch(request: LaunchRequest, session: Session, next: @escaping (StandardResult) -> ()) {        let standardResponse = generateResponse(message: "Hello Swift")        next(.success(standardResponse: standardResponse, sessionAttributes: session.attributes))    }}

In the request handler, your custom skill can implement any logic your skill requires. To enable asynchronous code (for example calling another HTTP service), the result is passed on via the next callback. next takes a enum that’s either .success and contains an Alexa response or .failure in case a problem occurred.

To keep things simple, we’ll pass back a message that Alexa will speak out loud to the user:

func generateResponse(message: String) -> StandardResponse {    let outputSpeech = OutputSpeech.plain(text: message)    return StandardResponse(outputSpeech: outputSpeech)}

Debugging Your Code with Local HTTP Server

Invocation of a RequestHandler as part of a Swift server is done via Amazon’s HTTPS API where the Alexa service calls your server with a POST request. In the following code, Kitura is used as a web framework, but any other web framework would work equally well:

import Foundationimport AlexaSkillsKitimport AlexaSkillimport Kiturarouter.all("/") { request, response, next in    var data = Data()    let _ = try? request.read(into: &data)    let requestDispatcher = RequestDispatcher(requestHandler: AlexaSkillHandler())    requestDispatcher.dispatch(data: data) { result in        switch result {        case .success(let data):            response.send(data: data).status(.OK)        case .failure(let error):            response.send(error.message).status(.badRequest)        }        next()    }}Kitura.addHTTPServer(onPort: 8090, with: router)Kitura.run()

To run a local HTTPS server:

• Make sure the sample builds by running swift build
• Generate an Xcode project with swift package generate-xcodeproj
• Open the generated Xcode project, select the Server scheme and run the product (CMD-R). This will start a server at port 8090
• Install ngrok via brew cask install ngrok. This tool allows you to expose a local HTTP server to the internet
• Run ngrok http 8090 and copy the HTTPS URL generated by ngrok (it looks similar to https://c4ba192c.ngrok.io)

ngrok exposes your local server to the public internet thus allowing the Alexa Voice Service to call into your custom skill running in Xcode.

Configuring the Alexa Skill

To hook up your custom skill to Alexa:

• Go to the Alexa console and create a new skill
• Skill type: Custom Interaction Model
• Intent: {"intents": [{"intent": "TestIntent"}]}
• Sample utterances: “TestIntent test swift”
• SSL Certificate: Select “My development endpoint is a sub-domain of a domain that has a wildcard certificate from a certificate authority”
• Service endpoint type: HTTPS (use the URL from ngrok)

Now you can test the skill in the Alexa Console’s Service Simulator using the utterance “test swift”. This will call your local server allowing you to modify and debug your code while interacting with the Alexa service.

Running Tests for Your Code

Before uploading to Lambda, it’s worthwhile to run your unit tests in a Linux environment and run integration tests that simulate the execution environment. The sample provides run-unit-tests.sh to do the former and run-integration-tests.sh to do the latter.

run-unit-tests.sh builds and tests the Lambda target inside a Swift Docker container based on Ubuntu because there's currently no Swift compiler for Amazon Linux (based on RHEL). Executables built on different Linux distributions are compatible with each other if you provide all dependencies necessary to run the program. For this reason, the script captures all shared libraries required to run the executable using ldd.

To prove that the resulting package works, run-integration-tests.sh runs a release build of the Swift code inside a Docker container that comes close to Lambda’s execution environment (unfortunately, Amazon only provides a few Docker images that don't necessarily match what Lambda is using).

The integration with Lambda is done via a small Node.js script that uses the _childprocess module to run the Swift executable. The script follows Amazon's recommendations to run arbitrary executables in AWS Lambda.

After configuring Travis, you can run the same integration script also for every commit.

Deploying Your Code to Lambda

For Lambda, you need to create an executable that takes input from stdin and writes output to stdout. This can be done with the following code:

import Foundationimport AlexaSkillsKitimport AlexaSkilldo {    let data = FileHandle.standardInput.readDataToEndOfFile()    let requestDispatcher = RequestDispatcher(requestHandler: AlexaSkillHandler())    let responseData = try requestDispatcher.dispatch(data: data)    FileHandle.standardOutput.write(responseData)} catch let error as MessageError {    let data = error.message.data(using: .utf8) ?? Data()    FileHandle.standardOutput.write(data)}

Note that this code uses the same RequestHandler that was used for the HTTP server thus minimizing the differences to the development environment.

To deploy your code to Lambda:

• Run run-integration-tests.sh to produce a zip file at .build/lambda/lambda.zip with all required files to upload to Lambda
• Create a new Lambda function in the AWS Console in the US East/N. Virginia region (for Europe use EU/Ireland)
• Use an Alexa Skills Kit trigger
• Runtime: NodeJS 4.3
• Code entry type: ZIP file (upload the lambda.zip file from the previous step)
• Handler: index.handler
• Role: Create from template or use existing role

Once you uploaded the Lambda function, you can use the test actions in the AWS Console, for example by using a Start Session action.

Configuring the Alexa Skill for Lambda

After creating the Lambda function, you can now create an Alexa skill. If you have previously created an Alexa skill for the local HTTP server — the only difference is the service endpoint:

• Go to the Alexa console and create a new skill
• Skill type: Custom Interaction Model
• Intent: {"intents": [{"intent": "TestIntent"}]}
• Sample utterances: “TestIntent test swift”
• Service endpoint type: AWS Lambda ARN (use the ARN for the Lambda function from the AWS Console)

Now you can test the skill in the Alexa Console using the utterance “test swift”. More details on configuring Alexa skills can be found on Amazon’s developer portal.

Wrapping Up

Check out the swift-lambda-app repo on GitHub for the code and scripts to develop and deploy a simple Alex skill in Swift. In future articles, I’ll provide more details on how to write useful skills. Meanwhile, you can browse Amazon’s documentation or contact me on Twitter if you have any question.