September 2019 Summaries

The tutorial outlines the creation of a Laravel application that utilizes queues to send SMS messages to users whose birthdays are today. The process involves setting up a database queue, creating a job to send the birthday message, and configuring the queue driver. The application uses the Twilio PHP SDK to send the SMS. The tutorial covers the necessary steps to create a database queue, including seeding the database with sample data, installing the Twilio PHP SDK, and configuring the Twilio account credentials. It also explains how to generate a job using the Artisan command, dispatching the job to process the birthday messages, and testing the application's functionality.

Node.js is an event-driven runtime environment for JavaScript that provides a way to run JavaScript code on the server-side of the browser/server relationship. It uses the V8 engine and offers concurrency models, HTTP support, and support for asynchronous programming capabilities like callbacks and Promises. The source code is available on GitHub, and Node.js can be installed for free from the official website. Once installed, npm (the Node Package Manager) can be used to install add-on libraries that extend JavaScript functionality. Node.js has a minimal impact on system resources and can be run from the command line with the `node` executable. To get started with Node.js, one should first understand its purpose and how it works, as well as learn about concurrency models and asynchronous programming capabilities.

The latest release of Laravel 6.0 introduces Ignition, a new error handler that replaces Whoops as the default error handler. Ignition is designed from the ground up to handle Laravel's specific errors and provides suggestions on how to resolve them, as well as automatically fixing common problems. It also offers detailed debug information, including stack traces, request and server details, and database queries. Additionally, Flare, a paid SaaS product, complements Ignition by providing a centralized platform for error management in production environments, allowing developers to track errors and diagnose issues more efficiently.

A nonprofit or social enterprise can build an SMS Panic Button using a free Twilio account and an IoT button like Flic to discreetly send an urgent call for help in emergency situations. The panic button sends an HTTP request that triggers a Twilio Function, which then sends an SMS message to a predefined number. This flow requires configuring the button to execute an outgoing HTTP request and linking it to the Twilio Function. A Twilio Function is created with a predefined phone number and sends a message whenever an HTTP request comes in. The panic button's logic works as follows: a single click triggers an HTTP request that leads to the Twilio Function, which then sends an SMS message to a list of numbers defined by the user.

This post demonstrates how to use Twilio's SMS service in conjunction with Azure Functions to send positive affirmations to friends via text message. The project uses C# and the Microsoft.Azure.Cosmos.Table library to interact with an Azure Table Storage database, which stores the quotes and phone numbers of users who have sent them. The code includes two Azure Functions: InboundFunction, which receives incoming SMS messages and saves the quote in the table storage; and OutboundFunction, which sends a random quote to all friends at 10 am every day using Twilio's SMS service. The project also includes logging and error handling mechanisms to ensure that the functions run smoothly and can be tested locally before being deployed to Azure.

The tutorial describes how to create a Slack app that sends SMS using Twilio and Laravel PHP. The process involves setting up a new Laravel project, creating a Slack app with slash commands, installing the necessary dependencies, and implementing the logic in the IncomingController class to send an SMS to a user tagged in the command. The tutorial also covers how to use the Slack API to fetch user details and Twilio SDK to send SMS. The final application is tested by sending a message from Slack, which triggers the Laravel application to send an SMS to the user's mobile number.

The Twilio Mobile Core is a software-based platform that enables wireless devices to connect to cellular networks independently of their radio technologies, providing global scale, high availability, and fast iteration cycles. It allows developers to build new use cases and provides insights for scaling fleets of IoT devices. The core works by authenticating and authorizing devices to connect to the network through attachment procedures, establishing dedicated tunnels between the device and the carrier network. Twilio's Mobile Core is 100% software-based, deployed on Amazon Web Services, and offers a continuous deployment strategy with integrated event streaming platforms for collecting and analyzing events produced by the network. It provides powerful APIs for fine-grained control over fleets of devices and supports innovative features through an agile process.

This tutorial provides a step-by-step guide on how to initiate a voice call from a Laravel PHP application using Twilio's Programmable Voice feature. The tutorial assumes the reader has basic knowledge of PHP, Composer, and Laravel. To complete this tutorial, one needs to install a new Laravel project, configure the Twilio PHP Helper Library, create a controller for handling voice calls, design a view for making outbound calls, look up the phone number to ensure its validity, initiate the call, record the call, and connect it to a route in the routes/web.php file. The tutorial concludes by providing additional resources and encouraging readers to explore other uses of Twilio's Programmable Voice feature.

This tutorial guides on how to forward voicemail transcriptions from Twilio's Voice API to a Slack channel using Laravel PHP. It starts by setting up the necessary tools and environment, including creating a new Laravel project, installing the Twilio PHP SDK, and setting up a Slack Incoming Webhook. The code then creates a model and controller to save calls as voicemails, receive transcripts, and forward them to the Slack channel. The tutorial also covers creating endpoints for Twilio webhooks and testing the app with Ngrok and a temporary public URL.

The Raspberry Pi can be bricked by shorting the +3 Volt Pin, overpowering it with a high-voltage power source such as an old USB battery, or using an old power over ethernet HAT that damages the USB ports. These methods are not recommended and can render the device unusable, but they demonstrate the importance of handling hardware with care and caution.

The author, Marcus Battle, shares his experience with creating a Teacher-Parent Broadcast App using Laravel 6.0 and Twilio's Voice API to broadcast pre-recorded messages to multiple phone numbers. The app enables parents to receive voice updates from their children's teachers, providing a more efficient and personalized way of communication. The application implements Laravel's authentication system, stores users' contact information in the database, and uses a console command to trigger the broadcast. The final step involves setting up an endpoint to play a custom voice message to each recipient.

Implementing multi-party calls with VoIP and GSM using the Programmable Voice API allows for seamless communication between multiple users, including translators and aid workers. This guide focuses on building a robust infrastructure to handle dialing in other users, using only their phone numbers, behind the scenes. The backend is built using Python Flask App for Twilio, and endpoints are called from the frontend (Web/Mobile App) and the Twilio console. To complete this tutorial, one needs a free Twilio Account, basic working Python Flask App for Twilio, a Twilio Phone Number, a Programmable Voice TwiML App, an Amazon S3 Bucket, and a Frontend App that communicates with the Twilio Console / Flask App. The guide outlines how to set up conferences as agent conferences, create a voice request URL for the TwiML App, start a call, add the caller to the conference, handle edge cases such as when only one person is left in the conference or the original caller leaves before the callee picks up, and end the conference call.

Apple has released iOS 13, which includes a new feature to combat unwanted robocalls called "Silence Unknown Callers" that sends calls from unrecognized numbers directly to voicemail. This feature may help reduce the annoyance of illegal robocalls but raises concerns about unintended consequences, such as consumers potentially missing important calls. The success of this feature depends on various factors, including how well consumers use it and whether other technologies, like SHAKEN/STIR, are used in conjunction with it to provide a more secure authentication framework. Twilio is working on a program that provides context about why organizations are calling, aiming to improve the user experience and reduce unwanted calls.

The Sign In With Apple feature was announced at Apple's World Wide Developer Conference in June 2019 as a new OAuth solution that allows users to quickly sign into websites and apps using their Apple ID, providing a unique app-specific email address through a private relay service. To ensure secure delivery of emails, developers must follow specific steps set by Apple, which includes Domain Authentication with SendGrid, and may require additional assistance from the Support Team for more complex features.

It's complicated' to stop illegal robocalls, which are a significant threat to consumers and businesses alike. The issue is multifaceted, with legitimate calls being spoofed by bad actors to impersonate identities, causing frustration for recipients. To combat this, SHAKEN/STIR, a protocol developed by the Internet Engineering Task Force and the Alliance for Telecommunications Industry Solutions, provides near-instant traceback of bad actors and treats their future calls based on their reputation. Beyond SHAKEN/STIR, Twilio is developing Verified By Twilio, which displays actionable information consumers need to decide whether to take a call or not, such as the name of the organization calling and why. The goal is to restore trust in phone calls and make them something people look forward to again.

The National Telecommunications Commission of the Philippines has mandated a change to the country's local numbering plan for phone numbers in the 02 area code, which covers Metro Manila and neighboring areas. Starting October 6, 2019, all numbers will transition from 7 to 8 digits in length, with an additional "8" added to the end of the current 10-digit format. This change is designed to support the long-term growth of the Philippines' telecommunications market and is already being implemented by Twilio for its customers using local numbers in this area code. Customers are advised to inform their customers about the change, modify their Twilio applications as necessary, and update their databases to accommodate the new 8-digit format. The change will cause some disruption during the migration period, but Twilio will provide support to help customers through the transition.

jsoup` is a Java library used for parsing HTML and XML documents. It's designed to work with the flexibility and style of web browsers, which means it can handle malformed or "tag soup" HTML more effectively than traditional XML parsers. The author demonstrates how to use `jsoup` to fetch a webpage, extract data using CSS selectors, clean up malicious HTML, and prevent cross-site scripting (XSS) attacks. The library is easy to add to any Java project with no additional dependencies, making it a useful tool for web scraping and data extraction tasks.

A Node.js application is created to send WhatsApp messages to multiple recipients using Google Sheets as a data source and Twilio's API for WhatsApp. The application uses a JWT auth client to authenticate with the Google Sheets API, reads data from the spreadsheet, and sends personalized WhatsApp messages to each recipient. The code includes error handling and a recursive function to send messages one by one. The application is run using the `node index.js` command, and the console shows the SIDs of the sent messages.

The evolution of caller ID from its inception in 1968 to its current state is a complex process that has been shaped by the advent of cell phones and the rise of robocalls, spoofing, and phone scams. Despite the availability of caller ID services, consumers have not widely adopted them due to the limitations of traditional caller ID systems, which can be spoofed or tampered with. The introduction of SHAKEN/STIR technology aims to provide a more secure way to verify caller identity, but it still leaves room for doubt and uncertainty. New initiatives like Verified By Twilio aim to bridge this gap by providing additional context and information about the caller, such as their brand name and purpose. As the communications industry continues to evolve, there is a growing need for industry-wide cooperation and innovation to regain trust in phone calls and inboxes.

Twilio Media Streams and Google Speech-to-Text can be used for live transcription of phone calls, with the ability to send audio from a Twilio call to a server, where it is transcribed into text in real-time. The transcription results are then broadcasted to all connected clients, including browsers, allowing for real-time display of the transcript. This setup enables voice applications to extend their capabilities by providing live speech-to-text functionality.

The Principle of Least Privilege (POLP) is a cybersecurity strategy that restricts access to the lowest level necessary for users and systems to perform their tasks, reducing the risk of security breaches and data loss. By limiting access, POLP helps prevent internal threats from malicious employees or external attacks from hackers, while also making it easier to respond to incidents by isolating compromised systems. Implementing a POLP system requires communication, planning, and regular audits to ensure compliance with international standards, and can be challenging but ultimately saves time and money in the long run when compared to the fallout from a data breach or malware infestation.

Deploying Twilio Functions with the Serverless extension for VSCode is made easier by an open-source VSCode integration that makes it straightforward to deploy Twilio functions from your IDE. The extension adds 6 commands to the VSCode command palette, including `Create Project`, `Start Local Server`, and `Deploy`. With these commands, users can create a new project, develop locally, create a new function, deploy to development, create an environment, and activate production. The process involves several steps, including installing prerequisites, logging in to the Twilio CLI, installing the extension, and using the various commands to scaffold out the project's files, start a local server, create a new function, deploy to development, create an environment, and activate production.

Twilio Studio` is a powerful tool used to simplify the experience of building communication flows. It allows users to design interactions visually and share their work with others for collaboration and feedback. The author created an `SMS chatbot` using Twilio Studio and Functions to engage with volunteers and deliver information about different initiatives. The chatbot uses `Messaging widgets`, a `Split widget`, and `Set variables widget` to customize the experience based on user interactions. The author also used `Twilio Functions` to add a delay between messages, improving the conversation pace. The code for the chatbot is available online, allowing others to replicate the experience and build their own flows using Twilio Studio.

Twilio Functions` is a serverless runtime that allows developers to handle webhooks from programmable communication APIs like Twilio. The article demonstrates how to create a `Twilio Function` in ClojureScript using the `Shadow CLJS` compiler and the `Twilio CLI`. It covers the setup, configuration, and deployment of the function, as well as adding functionality such as responding to SMS with random quotes from Rich Hickey's collection. The article provides detailed instructions on how to build a functional Twilio Function in ClojureScript using Shadow CLJS and the Twilio CLI.

The Twilio Phone Number Provisioning API has undergone an important change effective September 10, 2019, due to increased regulatory compliance requirements for phone numbers worldwide. As part of this update, address requirements are now enforced via the API, and users must provide a valid address for newly provisioned regulated phone numbers, with error code 21631 being returned if no address is included. This change only affects phone numbers outside the US and Canada that fail to send an address in their API calls, and existing phone numbers in accounts should have been brought into compliance prior to this update. Regulatory requirements are increasing globally due to fraud, misuse, abuse, and national security concerns, with Twilio working to enable new number types and advocate for smart changes in requirements while preserving value for users. Customers can find more information on regulatory compliance, address requirements, and the change's impact on their accounts through various resources available on the Twilio website.

The Fallback policy in Polly is used to handle failures that cannot be recovered from by implementing fault tolerance in distributed systems. It provides a last line of defense by executing a specific action when all else fails, such as logging or notifying an admin. The Wait and Retry policy is combined with the Fallback policy to retry failed requests and provide additional resilience. A policy wrap allows multiple policies to be combined and executed in series, enabling flexible fault tolerance implementation. By using the HttpClientFactory pattern, instances of HttpClient are created that execute the WrapOfRetryAndFallback policy handler, providing a robust way to handle failures in service-to-service communication on the web.

Twilio and Authy are partnering to provide authentication customers with tools to address SIM swapping vulnerabilities, which hackers use to commit identity theft or account takeovers. The Authy trust-chain helps determine which app installs can be trusted for authentication by recording uniquely identifiable numbers assigned to every installed app, as well as the sequence of app installs and methods of installation. In a hypothetical scenario, a hacker attempts to use this system but is unable to authenticate due to the chain of trust established between Bob's devices, which prevents his Android phone from being trusted. The Authy API examines each authentication attempt and decides instantaneously which apps can be trusted for authentication. Twilio authentication customers should know that if an SMS-based one-time password is passed, no risk assessment is made unless there is already a device assigned to the user account, while a time-based one-time password from a known and trusted device allows the login, and a TOTP provided from an unknown device with SMS or phone call registration method does not trust the device.

Microsoft is moving ASP.NET Core 3.0 to general availability, marking a significant new entry in the course catalog for .NET web developers. The announcement is set for September 23rd at .NET Conf 2019, which will be held virtually this year. For UK developers, there are local events scheduled around the world, including a watch event hosted by Twilio's Layla Porter. To prepare for the new version, developers can refer to articles and guides on ASP.NET Core 3.0, such as those written by Shawn Wildermuth and Andrew Lock, or follow breaking news on GitHub's aspnet/Announcements channel. Additionally, Microsoft has released a step-by-step guide for converting from ASP.NET 2.2 to 3.0, along with other resources, including an episode on microservices on Channel 9.

SendGrid's Marketing Campaigns Free Plan offers a straightforward approach to setting up email automation, allowing users to send up to 6,000 emails per month for free. The process involves signing up for a free account, confirming the email, and setting up a sender name, which includes providing a friendly from name, email domain, and physical address. Users can create a list to organize contacts and establish an unsubscribe group to comply with marketing standards. Email templates can be created from scratch using a drag-and-drop editor or chosen from pre-made options. A signup form is built to gather new contacts, which triggers welcome email automation upon submission. The automation setup includes naming the automation, setting entry and exit criteria, selecting an unsubscribe group, and choosing the email content from previously created templates. Before going live, users can test their email automation with provided testing credits. Finally, by integrating the signup form into a website or sharing its landing page, users can grow their email list and develop their email marketing program.

Temporary storage in Twilio Functions allows for the creation of resources locally for one-off activities, such as creating a file with user-provided data. This storage is located in the temporary folder under the underlying OS filesystem and is intended for single-invocation jobs only, as contents are deleted when associated containers are brought down. A Twilio Function example demonstrates how to access and utilize this temporary storage by writing to and retrieving from it, showcasing its potential for adapting to business needs.

A tech enthusiast created an Internet of Things (IoT) button that delivers an SMS affirmation when pressed, using Twilio's IoT capabilities to counteract impostor syndrome. The project involved building a Raspberry Pi-based system with a LTE Cat 1 Pi HAT, a button, and a Twilio SIM card, which sends affirmations from a predefined API when the button is pressed. The author used a self-affirmation approach to combat negative thoughts, finding that taking physical action helped ground their emotions. The project's success was made possible by using Twilio's IoT capabilities without requiring WiFi configuration, allowing the button to be taken anywhere with cell service.

Email testing is essential to ensure the quality and effectiveness of digital communication, as it helps prevent errors such as broken links, poor image rendering, and messages being marked as spam, which can damage a brand's reputation and decrease customer engagement. The process involves checking for typos, verifying image and format rendering across various devices and email clients, performing spam tests to avoid triggering filters, and validating links to ensure they direct to the intended and credible destinations. Tools like Email on Acid and Litmus streamline this process by providing a platform to test emails across different inboxes and devices, saving time and enhancing reliability. High-quality emails lead to improved customer experiences, better engagement, and increased deliverability rates, creating a positive cycle that benefits both senders and recipients. Twilio SendGrid incorporates these testing features into its platform, offering users the ability to scan emails for potential issues before sending, thereby maintaining a trustworthy brand identity.

The article guides readers through setting up a Twilio Functions project using TypeScript and the Serverless Toolkit. The setup involves installing Node.js, npm, and the Twilio CLI, creating a new project with `twilio serverless:init`, adding TypeScript to the party by installing it as a devDependency and configuring the tsconfig.json file, and writing a first Twilio Function in TypeScript. The article then covers enabling strict mode, adding types, and deploying the Functions to Twilio. Finally, it provides tips for further development and debugging of the project.

JavaFX is a Java toolkit for making GUI applications that run on Windows, MacOS or Linux, and mobile devices. It is the successor to Swing and AWT toolkits and has been part of the OpenJDK project since its release in 2018. To create a JavaFX desktop application from scratch, one needs to set up a Maven project with the necessary dependencies, configure the Java modules, and write the Java code that extends javafx.application.Application and implements the start method. The example application builds an interactive GUI with a label, text fields for phone number and message, and a button to send SMS messages using Twilio's SMS API. After setting up the Twilio account credentials as environment variables, the application sends a message when the button is clicked.

Azure Functions were used to create a function that sends daily SMS updates about the status of London's Tube lines. The function uses Twilio and Azure's TFL API to retrieve information about each line's status, then sends an SMS with the latest info. To set up this project, you need to create an Azure account, install the required tools, and configure your Azure Function App. Once configured, you can test the function locally using Postman or cURL, and then deploy it to Azure for use in production. The author of the tutorial received a successful SMS update from their phone, but notes that technology can't always save us from other people's armpits when it comes to delays on public transportation.

You can quickly calculate powers of two in your head by using the rule: add three zeros for each ten in the power, then multiply by whatever is left. This trick is based on three key facts: 2(a+b) = 2a × 2b, 210 is close to 1000, and knowing the powers of 2 up to 210. By approximating numbers using this rule, you can quickly estimate values like the difference between 243 and 7 trillion or the number of items that can be stored with a 32-bit identifier. The trick may underestimate the true answer by about 2.4% per 210, but it's good enough for quick approximations and can be improved upon by adding an additional quarter percent for each 210 in the calculation.