June 2017 Summaries

Lizzie Siegle's post explores utilizing Python, Flask, and the Openpyxl library to read and compare NBA statistics from an Excel spreadsheet. The tutorial demonstrates setting up a Python and Flask development environment, acquiring a Twilio phone number, and using Ngrok to make the Flask app accessible online. It explains how to install necessary libraries and write a function that maps players and their statistics from an Excel sheet into a dictionary. The core of the application is a Flask route that processes incoming SMS messages, parses player names and requested statistics, and compares the data before sending a response via Twilio. The post also encourages readers to explore further applications of Openpyxl for various data types and concludes with links to additional resources and the completed code on GitHub.

This article guides readers through building a Flask application in Python that uses the Clarifai API and Twilio MMS to receive picture messages over a phone number, analyze the images using image recognition, and respond with relevant keywords. The reader sets up their environment, installs dependencies, creates an account with Clarifai, and configures their Twilio account before building the Flask app. Once built, users can text a phone number with their own pictures for the code to analyze, receiving a response with tags or "concepts" associated with the image. The article explains how this all works, including how Twilio sends requests to the Flask app and how Clarifai's API is used for image recognition.

This article provides a step-by-step guide to sending emails through SMS using JavaScript and Node.js, leveraging Twilio's API. The process involves setting up a Twilio account, installing necessary dependencies, cloning a starter project, and configuring the application to receive SMS messages. Once an SMS message is received, the application prompts the user for the next step in the email creation process, which includes entering the recipient's email address, subject, and message body. The application then uses Nodemailer to send the compiled email to the specified recipient. Throughout the tutorial, the authors provide code snippets and explanations to help readers understand the process and implement it themselves.

The article guides the reader in creating a multi-party chat application using Twilio Programmable Chat with JavaScript. It outlines the steps to set up a server component for access and authentication of chat clients, including generating an access token from Twilio's Programmable Chat Service. The client component involves creating a basic user interface for the chat clients, handling token generation, and initializing the chat client. The application demonstrates how to join existing channels or create new ones, send messages, and display chat history. It also provides resources for adding features like roles and permissions, message read statuses, user presence, push notifications, integrating other channels, and using a bot engine.

Democracy Works is a nonprofit organization that aims to increase voter turnout in the US by 80% by 2024 through its online app TurboVote. The app helps Americans register to vote, track local and national elections, submit absentee ballots, and learn critical election information. To engage voters effectively, Democracy Works prioritizes using text messaging as a primary medium, leveraging Twilio Programmable SMS to send reminders, voter registration forms, and answer voter questions. The organization believes that simplicity and the human element are key to its success, with technology serving as a tool for human-to-human conversation rather than a replacement for it. By making voting more accessible and engaging, Democracy Works is achieving significant gains in voter registration and participation rates, including 62% of users successfully registering and voting in the 2016 presidential election.

The article provides a step-by-step guide on how to send SMS notifications to readers when new WordPress posts are published. It requires the installation of a custom WordPress plugin, which allows users to store their phone number and receive instant SMS notifications when a new post is published. The plugin uses Twilio's PHP library to send text messages to subscribers, who need to have their phone numbers stored in their user profiles. Once activated, the plugin can be tested by publishing a new post and sending an SMS notification to all subscribers with registered phone numbers.

Twilio Segment has developed a sophisticated de-duplication system to address the challenge of delivering messages exactly once within a data pipeline, despite the inherent complications of distributed systems where data can often be delayed or reordered but not lost. Their previous system, which relied on Memcached for key storage and atomic operations, was costly and memory-intensive. The new system leverages Kafka and RocksDB to efficiently manage message duplication by assigning unique IDs to messages, storing them in Kafka for durability, and using a Go-based deduplication worker to process them. RocksDB's log-structured-merge-tree architecture allows for fast writing and efficient key management, while Kafka acts as the source of truth to ensure reliability and consistency in message delivery. This system enables Twilio Segment to handle billions of messages with increased reliability and at reduced costs, by moving data storage to disk and optimizing performance through partitioning and batching reads and writes. The new architecture has proven successful over several months, significantly improving upon the limitations of their previous Memcached-based approach.

The Particle Photon is a small device that can be used for building Internet of Things projects due to its 120 MHz ARM Cortex M3 processor, WiFi capabilities, and low cost. It can send SMSes and MMSes using Twilio's API by following these steps: creating a Twilio account, purchasing an SMS-capable phone number, retrieving the Twilio account SID and API secret, setting up a Particle Webhook with Twilio, and flashing the code to the Photon. The process is straightforward and can be completed in 20 minutes. Additionally, the Photon can also send MMSes by publishing to two event names: "twilio_sms" for SMSes and "twilio_mms" for MMSes, which allows sending media messages with images.

A Twilio Functions application was built to monitor cryptocurrency prices using CoinMarketCap's API and send SMS updates about price changes. The application uses Twilio's serverless environment, JavaScript, and the got module to make HTTP requests to CoinMarketCap's API. The application sends an SMS message with the current price of a specified cryptocurrency, including its symbol, price in USD, and percent change in 24 hours. The application also handles errors by catching any exceptions that occur during the HTTP request or when parsing the response from CoinMarketCap's API.

The Particle Electron is a powerful Internet of Things building block that can be used to send SMSes and MMSes with Twilio's Messaging APIs. To get started, users need to sign up for a Twilio account, find or purchase an SMS-capable number, retrieve their Twilio credentials, prepare their Particle Electron for flashing, and set up a webhook in the Particle console. The process involves using the Particle Web IDE to copy and paste code, which can be used to send SMSes and MMSes with custom data, including images. Users can then power cycle or reflash their Electron to test the integration, and monitor sensor readings or other applications that require messaging capabilities.

Cell-Ed is an organization that uses SMS-based learning to educate people with limited access to technology, such as basic mobile phones, on essential skills like reading and writing in English. The program, powered by Twilio, allows learners like Lucia to receive personalized coaching and support through phone calls and text messages, enabling them to learn at their own pace from anywhere. By bridging the digital divide and providing a relevant and practical learning experience, Cell-Ed has achieved a high completion rate of 75%, compared to traditional classroom-based curriculums, which often struggle with diverse learner backgrounds. The organization's approach prioritizes individual focus, asynchronous learning, and constant encouragement, making literacy education accessible to those who need it most.

Twilio has hired Lizzie Siegle as a developer evangelist to help inspire and equip developers with the "mind of a hacker, heart of a teacher, and soul of an entrepreneur." Lizzie's background in coding and her experiences attending hackathons and organizing tech events for high school girls have driven her passion for helping other developers. She aims to use her skills as a developer to teach others and inspire them to learn and grow in the field of technology. With her unique blend of technical expertise, teaching experience, and enthusiasm for community-building, Lizzie is excited to join Twilio's evangelism team and help spread the word about the power of coding and collaboration.

This summary highlights the use of Amazon Web Services' API Gateway and AWS Lambda to build a serverless API for Twilio SMS. The problem being solved is the need for a scalable, secure, and easy-to-manage service that allows multiple users to access the same Twilio service while controlling access and usage. The traditional approach involves setting up a web server, framework, authentication mechanism, and monitoring system, which can be time-consuming and resource-intensive. In contrast, using API Gateway and Lambda provides a more efficient and cost-effective solution, allowing for the creation of a public API endpoint that can be accessed by multiple users without requiring a public IP address or DNS setup. The example demonstrates how to create an IAM role, Amazon API endpoint, Twilio Lambda function, security authentication, usage plan, and test the public API using Python requests.

Twilio Speech Recognition` is a powerful tool for voice applications powered by TwiML Gather. It allows developers to use spoken language in various languages, rather than just DTMF tones as input. A hotline example was created using Twilio Functions to test the feature and demonstrate its usefulness in interactive voice response (IVR) applications. The code for the application is available on Github, and it consists of several functions that work together to provide a menu-driven system with cat facts, number trivia, and Chuck Norris jokes. The system uses speech recognition to process user input and redirect calls to specific functions based on the user's request. The example showcases how Twilio Speech Recognition can be used to create engaging and interactive voice applications.

Twilio is a cloud communication platform that allows users to make and receive phone calls, send SMS messages, and more. A TwiML bin is a serverless developer environment that enables the creation of custom call flows. In this tutorial, Kyle Kelly-Yahner, a writer for Twitter, Facebook, and LinkedIn, shares a hack to create an apartment buzzer using Twilio and TwiML bins, allowing users to receive calls on their cell phone without needing to set up a server or keys. The solution involves signing up for a free Twilio account, buying a local area code number, creating a new TwiML bin, and configuring it to forward incoming calls to the user's cell phone.

At SIGNAL San Francisco, MissionMode hacked the video wall by using hackable hardware badges with Particle Electron onboard, which could control the massive display via text messages. The team, led by Scott Anderson, realized that automating the task of sending commands via their phones would be necessary to complete a picture before it was damaged by other conference-goer activity. They used Affinity Photo and Node.js to resize images and convert them into data, and then linked Apple's Messages app and JavaScript to unite the badges and the wall. The team's creativity and spontaneity led to an impressive display of their logo on the 40-foot video wall, showcasing the phrase "code is creative" in action.

The author of the post, Samuel Taylor, created a Python script using the Twilio API to automate course registration for his university's online courses. The script uses web scraping with BeautifulSoup to check the availability of seats in each course and sends SMS notifications to users who have subscribed to receive updates. The script also uses Redis to store subscriptions and validates that users are asking for valid courses. The author used a Flask web framework to handle SMS messages and TwiML responses. The script is run automatically every three minutes using Cron, allowing it to notify users of available seats in real-time.

The guide outlines a process for receiving SMS messages on a LinkIt ONE using Programmable Wireless, AWS IoT, and Lambda. It starts by setting up an API Gateway mock endpoint to receive incoming messages from Twilio, which triggers a Lambda function to publish the message to an MQTT topic subscribed to by the LinkIt ONE. The Lambda function extracts key information from the message and sends it back to the LinkIt ONE for processing. The guide then covers setting up IAM permissions for the Lambda function to publish to the MQTT topic, building out the API Gateway mock endpoint with a Lambda integration, and deploying the API to production. Finally, the code provided demonstrates how to handle incoming messages on the LinkIt ONE using the Twilio message handling callback.

The author of the text, Kevin Thompson, attended Twilio's SIGNAL conference where they set up a massive 40-foot video wall and handed out hackable wireless badges to attendees. The author found that they could send commands to the badge using a short code, which would affect their personal block on the video wall. After figuring out how to send text messages programmatically through the Messages app on their MacBook, the author used Ruby to create a script that could draw pixel art on the display by sending instructions as text messages. The script utilized the RMagick library for ImageMagick to manipulate images with Ruby and convert pixel data into a series of instructions that could be sent to the video wall application. To optimize the script, the author omitted transparent pixels, which significantly reduced the number of pixels needed to draw an image, making it possible to display test images on the video wall in a reasonable amount of time. The author successfully sent multiple images to the video wall, including a pixel art avatar of Phil Nash from Twilio, and documented their process and findings on Twitter and Gist.

XVim is a tool that allows users to add Vim keybindings and functionality to Xcode, a popular integrated development environment for iOS application development. XVim enables users to experience the modal text editing of Vim within Xcode, making it easier to navigate and edit code. To use XVim, developers must first prepare a certificate for code signing, which involves creating a digital certificate through Apple's developer program. Once this is done, users can build XVim by cloning the GitHub repository, compiling it with `make`, and customizing their `.xvimrc` file to suit their preferences. With XVim, developers can now enjoy the benefits of Vim's modal editing within Xcode, making development more efficient and enjoyable.

Plaid, an API that provides access to financial services data, and Twilio, an SMS service provider, can be used together with Python to create a daily spending summary via SMS. The user sets up Plaid accounts for two banks and obtains their credentials. They then use these credentials to obtain transactions from both accounts using the Plaid API. The code filters out certain categories of transactions, such as transfers, credit card payments, and deposits, and only includes transactions with a positive amount. The total spend is calculated by summing up the amounts of all remaining transactions. An SMS message is then sent to the user's phone with their daily spending summary. The app can be extended to track spending over multiple days, categorize items, or even interact with users through voice commands.

This application allows users to register their phone numbers to receive notifications when a specific text message is received. The notification includes a pre-set message that can be customized by the user. The application uses Python, Flask, and Twilio to send notifications via SMS or voice calls. It also has an endpoint for handling incoming messages from registered users, which can choose to receive either SMS or voice calls. The application can be run on a local server or remotely, and requires no prior setup beyond installing the necessary dependencies and configuring the Twilio account.

In 2017, Kyle Kelly-Yahner created a working phone number that plays Smashmouth's "All Star" when someone calls, as well as texts back the song's lyrics to anyone who texts. To achieve this, he used Twilio, a cloud communication platform, and created custom TwiML bins for both voice and text responses. The resulting "All Star" line was completed by simply saving the TwiML configurations and testing the number, which can be accessed at 830-476-5664.

PATH's innovative approach in Zambia is utilizing SMS data alerts to help end malaria by providing a community surveillance system that triggers targeted responses when a positive malaria case is detected. The organization has partnered with Twilio to implement Viz Alerts, an open-source Python script that identifies data gaps and prompts health workers to submit missing reports via SMS. This initiative has led to a significant reduction in missing report volume, with a 21% decrease across 200 health facilities. By leveraging technology and community engagement, PATH aims to further improve the data collection process and expand its efforts to other provinces in Zambia.

Twilio has announced the public beta of Agent Conference, a new set of conference features that make it easy to connect contact center agents to customers. The feature includes Agent Whisper, which allows supervisors to coach agents in real-time, and an Outbound Conference Call API, which enables agents to hear the state of outbound calls while still being in a conference. These features are now available in public beta, and Twilio is pricing them starting at $0.0033 per participant per minute. Agent Conference can be enabled on any Twilio account, and developers can check out the documentation for more information on how to implement it. The team plans to enhance the feature with better visibility and control over participants via a client-side JavaScript SDK and add other features in the future.

In this blog post, Phil Nash explores how to validate input data in a Ruby application using ActiveModel::Validations, specifically in the context of a Sinatra app that utilizes Google Spreadsheets as a database. He outlines the process of refactoring the application to capture user input as a Ruby object, enabling validation of essential fields such as name, email, and phone number. Nash demonstrates how to incorporate ActiveModel::Validations to enforce the presence of required fields and format checks for email addresses, and he extends functionality with a custom validation for phone numbers using the Twilio Lookups API. The tutorial concludes with updating the app to provide user feedback on validation errors, thus ensuring the integrity of data before submission to Google Sheets. Nash also invites discussion on utilizing ActiveModel components outside of Rails, emphasizing the versatility and utility of these tools in Ruby applications.

This tutorial describes how to build an application that forwards emails to SMS using Node.js and Twilio. To start, you need to set up a Twilio account, install Node.js and npm, and create an IMAP client to receive email notifications. The application uses Express to serve as a web server, which receives the email notifications from the IMAP client and parses them to send as SMS messages. The tutorial also covers how to modify the package.json script to run both servers in one command, test the application, and handle edge cases like emails that exceed the character limit imposed by Twilio.

When a dog with limited mobility presses a button connected to a Raspberry Pi, Node.js, and Twilio, it sends a text message to the owner's phone via Twilio's API, allowing for communication on a more nuanced level between humans and dogs. The project utilizes a minimal setup consisting of a Raspberry Pi 3, a momentary button, and power supply, with all the necessary code publicly available on GitHub. Trevor Miller built this hack after being inspired by the idea of dogs communicating with humans in a more sophisticated way.

Twilio has announced Area Code Geomatch, a new feature of its Messaging Services that automatically prioritizes sending messages from phone numbers in the same area code as the recipient in the US and Canada. This feature is now available for all Twilio accounts and is free to use. With Area Code Geomatch, users can easily enable this functionality by visiting the Messaging Services section of the Console and checking the box for Area Code Geomatch. The feature helps to provide a local identity to businesses, ensuring that customers receive texts from numbers in their local area code, which is essential for a smooth customer experience.

Dominik Kundel explains how to write a Node.js module using TypeScript, which can be used by both JavaScript developers and TypeScript developers. He starts by creating a new directory for the module, initializing the `package.json` file, installing dependencies such as the TypeScript compiler and the emojione module, configuring the TypeScript project with a `tsconfig.json` file, writing the module code in an `index.ts` file, compiling the code to JavaScript and TypeScript definitions files, preparing the package.json for publishing, and consuming the module in both JavaScript and TypeScript projects. The author notes that there are benefits to using TypeScript, such as better authoring experience, type safety, and down-transpilation of cutting-edge features.

The blog post discusses the development of ksuid, a Golang library for unique ID generation, which draws inspiration from the UUID standard while adding time-based ordering and user-friendly representation formats. The narrative explores the historical evolution of unique identifiers, starting from telephone numbers in the 1870s to the development of UUIDs by Apollo Computer in the 1980s, which became widely adopted in distributed computing environments. The post highlights the limitations and security concerns of earlier UUID versions that relied on hardware identifiers, leading to the popularity of UUID Version 4, which uses random data to avoid such pitfalls. Inspired by these developments, ksuid was created to offer both simplicity and time-sortability, making it suitable for various applications, including those requiring temporal ordering without relying on hardware-based uniqueness. The post concludes with details about the open-source implementation of ksuid in Go, noting its advantages over traditional UUIDs in certain use cases.

This project involves building a smart doorbell using Twilio and Android Things. The backend is built using Node.js, which interacts with the Twilio API to make calls when someone presses the button on the doorbell. The Android application runs on an Android Things-enabled Raspberry Pi and uses Retrofit to communicate with the Node.js backend. When the button is pressed, the app makes a request to the backend's "/call" route, which initiates a call to the Twilio number associated with the user's phone. The call includes a voice message saying "There's someone at the door." The project also uses ngrok to forward the Node.js server to a public URL, allowing it to be accessed remotely. The application is tested by running it on the Raspberry Pi and pressing the button, which logs a message in Android Monitor when pressed. Finally, the app makes an MMS request using the camera module to send a picture of the person ringing the doorbell to the user's phone.

Flashing Lights`: How to Build a SMS to Morse Code Translator with a Particle Electron and Twilio The article discusses how to create an SMS-to-Morse code translator using a Particle Electron, Twilio, and the Particle Cloud REST API. The project involves connecting the Particle Electron's hardware components, such as the SIM card, cellular antenna, and battery, and then writing Python code to handle incoming SMS messages from Twilio. The code sends the Morse code translation to the Particle Electron via the cloud API, which blinks an onboard LED with the corresponding dot or dash sequence. The article also provides instructions on how to set up a Flask server to run the application, expose it to the public using ngrok, and update the firmware for the Particle Electron.

The SIGNAL 2017 conference has concluded, but its content is now available online for viewing. The event featured various sessions and tracks focused on different topics such as building SMS-powered wine bots, Twilio expertise, developer crafts, and scaling messaging for large users like Airbnb. The conference also announced that it will be held in London this September, with tickets available for purchase.

This article discusses the post-SIGNAL World hackpack v3, a device that was given to every attendee at the SIGNAL conference. The device allows users to experiment with coding and artistic creativity. To claim the device, users must follow specific steps depending on whether they claimed it at the conference or not. The process involves removing the SIM card from the device, which can be done by gently prying out the battery lead and rocking the antenna connector out of the socket. Once the SIM card is removed, users can reinsert it into the device to activate it. The device uses standard 2.54mm header spacing, making it compatible with breadboards, and can be programmed using the Particle platform. Users are encouraged to experiment with coding and come up with innovative applications for the device.