April 2019 Summaries

This summary highlights the key points of the text, which is about optimizing JavaScript application performance with Web Workers. The main issue discussed is that long-running scripts can block the main thread and slow down web applications. To address this, Web Workers are introduced as a way to run script operations in a background thread separate from the main execution thread. This allows for efficient performance by delegating laborious processing to a worker thread, which can be terminated when no longer needed. The article provides a demo application to demonstrate the impact of long-running scripts on web performance and shows how to use Web Workers to improve it. It also covers additional resources for learning more about Web Workers and their limitations.

Laravel provides a feature called "Laravel Queue" that allows developers to defer time-consuming tasks, such as sending emails, and prevent them from timing out. In this tutorial, we implemented Laravel Queue to send emails using SendGrid, a service that provides email verification features. We created a listener class to dispatch the mailing job when a new user is registered, and a mailable class to build the email template. We also set up queue drivers and tested our application to ensure that it was sending emails through the queue instead of the default workflow. The tutorial concluded by highlighting additional features of Laravel Queue, such as priorities, max job attempts, and rate limiting, which developers can use to make full use of this feature.

Twilio's Programmable Voice Mobile SDKs 3.0 is now generally available, offering improved audio quality, increased efficiency, and contextual calling experiences for users. The new version includes features such as support for Opus codec, call control functions, custom parameters, media statistics API, real-time insights, and AudioDevice API for iOS. These enhancements enable developers to build engaging and high-quality voice calling experiences directly from their apps, protecting users' information by connecting calls using VoIP, and providing a suite of programmability features that can be leveraged to unlock Twilio's suite of features such as creating conferences, transferring calls, and recording calls. With this release, developers can now make their customer call experiences even more engaging with improved audio quality, increased efficiency, and contextual calling, and get started with the new SDK through various guides and resources available on Twilio's website.

The article provides a step-by-step guide on how to integrate the Twilio API with Magento 2 for real-time SMS order notifications. The author assumes that the reader has a basic understanding of PHP and Magento, and guides them through creating a custom module, installing the Twilio SDK, implementing an event observer, and sending SMS notifications using the Twilio API. The article also covers debugging common errors, expanded functionality ideas, and security considerations.

Twilio Elastic SIP Trunking provides dynamic trunking capacity to place and receive pay-as-you-go phone calls through Twilio's network, which spans thousands of carrier partner connections and phone numbers across over 100 countries. To set up Twilio Elastic SIP Trunking, users need a Twilio account, a SIP network element, and specific configuration steps including provisioning the trunk through the Twilio Console, setting up termination and origination URIs, assigning telephone numbers to the trunk, and configuring authentication methods. The configuration process requires careful consideration of firewall settings, phone number formatting, and voice geographic permissions. With proper setup, users can migrate their existing communications infrastructure to Twilio's Elastic SIP Trunking product, layer on other features such as Programmable Voice and SMS, and create solutions that intelligently route calls using dynamically returned Twilio Markup Language (TwiML).

Setting up a development environment for creating Twilio Flex Salesforce plugins involves several steps, starting with creating a fresh Salesforce Sandbox or Developer Edition and setting up the necessary tools such as ngrok to expose the local instance of Flex. The guide also covers using Salesforce as an Identity Provider for Single Sign-On (SSO) and configuring the SSO settings in both Salesforce and Twilio Flex. Additionally, it provides instructions on adding the Call Center to Salesforce, customizing the UI, and integrating the plugin with the OpenCTI interface.

This tutorial demonstrates how to implement One Time Password (OTP) login and signup functionality in a Yii 2 PHP application using Twilio SMS. The application allows users to sign up with their phone number, receive an OTP via SMS, and log in using the OTP. The system ensures that only valid phone numbers are accepted and provides a secure way for users to authenticate themselves. The code is well-structured, and the tutorial covers essential aspects of implementing OTP authentication, including setting up models, controllers, and views.

http headers for a responsible developer`, developers connect people, building things that help and enable people. HTTP is the protocol used by computers to request and send data over the web. Request headers are key-value pairs giving information like browser version or file formats understood. Response headers give information on the resource or server itself. The web has to be safe, affordable, and respectful. Developers have the power to build a better web for everyone. HTTP headers can help you build better products by reducing waiting time, preloading resources, using feature policy, and serving tailored resources to users.

In this post, you learned how to verify phone number ownership with Twilio using ASP.NET Core Identity and Razor Pages. You created a typed client for the Twilio Verify API that uses best practices like HttpClientFactory, and used it from Razor Pages to send verification codes via SMS to users' phones. The code provided examples of creating pages for collecting user input, checking verification codes, and displaying confirmation success messages. After verifying ownership of a phone number with Twilio's Verify API, you could be confident that the user had access to their phone number. The example demonstrated how to integrate Twilio Verify into an ASP.NET Core Identity application using Razor Pages, providing a basic approach for implementing phone number verification in a real-world scenario.

This post demonstrates how to implement service discovery using Netflix Eureka and dynamic routing with Netflix Zuul in a Node.js microservices application built with Spring Boot. The application is designed to be modular, uniform, and testable, and it can scale horizontally by adding more instances of services running on different servers in different locations. The example shows how to register services with Eureka using a RESTful API and how to use Zuul for dynamic routing. The code is built using Java Archive (.jar) files that can be run in the Java SE Runtime Environment, making it easy to deploy the application in a container along with Eureka and Zuul. The example also covers how to implement a registration mechanism in both services, which are then used by the application to register themselves with Eureka. By following this post, developers can build scalable and robust microservices applications using Node.js, Spring Boot, and Netflix OSS integrations.

This tutorial by Andre Piper guides the integration of Twilio SDK into a Yii2 web application to create text message alerts for PayPal payments. The author assumes a basic understanding of PHP, Yii2, and Git, and provides step-by-step instructions on cloning the sample project, installing dependencies, and configuring Twilio and PayPal credentials. The tutorial covers how to conduct payment and SMS disbursement using the AppServices class, which handles methods such as generating payment URLs, making payments, and sending text messages. The example application demonstrates a simple payment flow, where users can select their preferred method of payment and receive a confirmation message via SMS after completing the payment process.

With the Twilio API for WhatsApp, developers can send messages to WhatsApp numbers, including plain text and files like images, audio, and PDFs up to 5MB. To get started, a Twilio account is required along with Ruby and Bundler installed, as well as the WhatsApp Sandbox Channel activated. The Twilio-ruby gem needs to be added to a new Gemfile and installed using Bundler. A sample code in `app.rb` can be used to send a message from the WhatsApp Sandbox number to the developer's own WhatsApp account, replacing placeholders with actual details such as account SID and auth token. Running this code results in receiving the message in the WhatsApp app. The Twilio API also supports sending media messages, including images, by adding a `media_url` parameter to the message creation call, which points to an online image file with matching content type header.

Twilio Voice API is used to record calls with a voice-enabled number, and the storage space should be kept below the chargeable limit to prevent added cost. The recording management can be automated using the recording status callback, download recordings programmatically via the REST API, save the recordings in Dropbox, and delete the recordings programmatically via the REST API. A PHP development environment Laravel is used for this tutorial, which includes installing Twilio SDK for PHP, purchasing a voice-enabled Twilio phone number, setting environment variables, creating routes to generate TwiML for outbound and inbound calls, saving the recording in Dropbox, and deleting the recordings. The complete code for the tutorial can be found on Github.

This summary provides an overview of how to build resilient service-to-service communications in ASP.NET Core using Polly, a .NET resilience framework. The author creates two web services: an unreliable "temperature" service and a dependent "weather" service that calls the temperature service. The weather service uses a simple retry mechanism with Polly to make reliable requests to the temperature service. With just a few lines of code, the application becomes more fault-tolerant and can withstand failures in the network or other external factors. The author emphasizes that this is not the only type of retry used by Polly, but rather a basic example of how to get started with the framework.

Twilio SendGrid processes over 50 billion emails every month, making it imperative to protect recipients' information from phishing attacks. The company measures its success in preventing malicious email through its Inbox Protection Rate, which stands at 99.97% as of March 31, 2019. To achieve this, Twilio SendGrid uses machine learning technology called Phisherman, trained on vast amounts of data to identify patterns in abusive email content and flag suspicious emails. The company's Compliance Agents review caught phish to refine the system and prevent false positives from affecting legitimate senders. With its massive scale comes a responsibility to increase transparency around security measures and data usage, setting thresholds for industry-wide standards.

The Twilio API for WhatsApp allows users to send and receive media messages, including images, audio files, and PDFs up to 5MB. To use this feature with Node.js, developers need a Twilio account, Node.js, and a package manager like npm installed, as well as an environment variable set for the Account SID and Auth Token. The process involves installing the twilio helper library, creating a new file with sample code, and running it to send the first media message. However, there are differences between MMS and WhatsApp media messages, including limitations on file types and session duration, which should be taken into consideration when using this feature.

The project involves building a personal training exercise bot using Python, Zappa, AWS, and Twilio SMS. The bot aims to provide users with a workout plan each day, taking into account their preferences and providing a balanced routine. The development environment is set up with a virtual environment, AWS Lambda function, Flask session object, DynamoDB database, and Twilio package. The code defines a main function that handles incoming messages, builds a workout based on user input, and logs the workout in the DynamoDB database. The bot also includes features like conversation flow management, validation of workout progress, and deployment to AWS using Zappa.

Create-twilio-function is a project generator that makes it easy to start and develop Twilio Functions projects locally. It uses twilio-run, a serverless platform for running Node.js, and can be used to create new projects with just one command, asking for credentials or using stored environment variables. The generated project structure includes a .env file, gitignore, nvmrc, assets directory, functions directory, node_modules, package-lock.json, and package.json. A start script is defined in the package.json to run twilio-run --env, allowing users to test their Functions locally with just one command. The tool also provides an example function to get started, and is currently being worked on to include API for deployment to Twilio.

The article discusses hacking the Twilio Client SDK to play videos over the phone using WebRTC. It starts by adding a media element, such as an HTML5 video tag, to the page and creating a global JavaScript variable that captures the audio stream from the video element. The article then modifies the Twilio Client JavaScript SDK to inject the audio stream into the phone call, allowing for dynamic audio playback over the phone. This hack can be used for various purposes, including mash-ups, virtual instruments, and testing audio via PSTN, and is demonstrated with a working demo that can be viewed on YouTube or GitHub.

Nomorobo, a company that has been protecting people and businesses from phone scams for the past 6 years, is now making its real-time feed of IRS call-back scammers available for free to help combat one of the most notorious and dangerous robocall scams. By providing this data to phone companies, Nomorobo hopes to help end the IRS scam and other unwanted robocalls that plague consumers during tax filing season. To achieve this goal, Nomorobo is working together with telecommunications carriers and other stakeholders in the communications industry, leveraging its award-winning phone security solutions and algorithms to monitor millions of calls daily. The company believes that by working together, it's possible to eliminate robocallers and bring relief to consumers and the IRS.

In this article, the author demonstrates how to implement account verification and login by phone in a Laravel application using Twilio's Programmable Voice API. The process involves setting up a new Laravel project, installing necessary packages, modifying the database schema, creating middleware and routes for verification, and implementing the actual call to verify the user's phone number. The article concludes that this is all it takes to achieve phone verification using Twilio's services in a Laravel application.

You can deploy and run Angular ASP.NET Core video chat applications on Microsoft Azure using Twilio Programmable Video, leveraging a fully managed enterprise-grade cloud platform for easy deployment and configuration. To get started, you'll need a GitHub account, Microsoft account, Azure account, Twilio account, Visual Studio 2017 or 2019, and access to the video chat project source code, which can be obtained from the author's GitHub repository or by following previous instructions to build it locally. Once you have your credentials set up, you can publish your application to Azure using Visual Studio, add your Twilio configuration credentials to app settings in Azure, and test your video chat application functionality in a browser.

To implement a compliant offline solution for PSD2 transactions, users can leverage Authy's Transactional TOTP feature. This involves generating a transaction string with specific parameters and encoding it in a QR code that the user scans using the Authy App. The Authy API is then used to verify the one-time password generated by the user, tying the transaction-specific information to the authentication event even when offline. By enabling Transactional TOTP on their Authy Application settings, users can ensure compliance with PSD2 regulations and secure their transactions.

Laravel is a popular PHP MVC framework that supports multiple SMTP providers by default, but SendGrid is not available out-of-the-box. This tutorial aims to help developers implement SendGrid as an SMTP relay in Laravel for sending emails to registered users, including email verification and tracking features. To set up the project, create a new Laravel application, install dependencies, add database connection details, create a SendGrid account, generate API keys, configure the mail driver, and enable authentication scaffolding with email verification. The tutorial also covers testing the application, verifying emails, and checking the activity on the SendGrid dashboard to understand how the process works.

With Twilio's Messaging API, users can programmatically send WhatsApp messages using Python. To start, a developer needs to set up their development environment by installing the required software and creating a free Twilio account with an activated WhatsApp Sandbox. The sandbox allows for prototype messaging without waiting for a dedicated number to be approved by WhatsApp. Once the sandbox is activated, developers can use it to send WhatsApp messages using Python code, which requires installing the Twilio Python library and setting environment variables for the Twilio account credentials. The code snippet provided demonstrates how to create a simple WhatsApp media message using a pre-approved template and a shared phone number from the Sandbox.

Maciej Treder's post guides readers through building basic JavaScript microservices using Node.js, demonstrating how to decompose a monolithic application into a distributed system with independent services. The tutorial outlines the process of creating two microservices—the "heroes" service and the "threats" service—each responsible for specific tasks and communicating via RESTful APIs. The "heroes" service manages a list of heroes with different superpowers, while the "threats" service handles various challenges these heroes can address. The post emphasizes the benefits of microservices, such as modularity, scalability, and independent deployment, allowing for the maintenance and extension of each service without impacting others. Readers are guided through setting up the services, testing them with tools like Postman and curl, and exploring how these services can be expanded in future projects.

A free Twilio account is required to identify a phone number carrier with Twilio's Carrier Lookup API, which can be queried via a terminal or tool like Postman. The API returns information about the carrier behind a given phone number in E.164 format, including the country code, national format, and carrier name. However, carriers rebrand themselves constantly, so the returned information may change over time. The accuracy of carrier lookups is limited due to the spoofing of numbers and the lack of regulation in the telephony industry. Twilio's Lookup API can be used for various purposes beyond carrier identification, such as validating phone numbers, identifying line types, and detecting robocalls.

Twilio is a cloud communications platform that provides legitimate companies with the ability to send wanted communications to their customers who have opted in. The company has released a feature to help users identify if a call or text passed through Twilio, allowing them to report unwanted communications. Users can text "Twilio" to +1 (855) 747-7626 to check if a number is serviced by Twilio and report any unwanted communications. If the number appears to be using Twilio, users will receive options to report it for spam, fraud, or abuse. Twilio aims to restore trust in communications and solve cell phone anxiety, working with carriers and regulatory bodies to address issues such as spoofing and robocalling.

You can use JavaScript and Node.js to send WhatsApp messages programmatically using Twilio's Messaging API. To start, you need to sign up for a Twilio account, activate the WhatsApp Sandbox, and install the required software, including Node.js, npm, and the Twilio Node library. You also need to set environment variables with your Twilio account credentials. With these steps complete, you can create a file called index.js that uses the Twilio library to send a WhatsApp message from your personal phone number to a predefined phone number in the Sandbox. After running the code, you should see the sent message in your messages. Note that there are other languages and blog posts available for sending WhatsApp messages using different programming languages.

Twilio has updated its Authy API to meet the new European banking law, PSD2, which mandates stronger two-factor authentication for online payments. The updated API includes a new method called Transactional TOTP, which enhances time-based one-time passcodes to meet PSD2 requirements by tying the code to specific transaction attributes. This allows for more secure and compliant authentication, while also providing offline capabilities and protection against man-in-the-middle attacks.

Verify v2 is a revamped phone verification API built from the ground up on the Twilio platform, offering improved visibility, enhanced fraud protection, and full integration with the Twilio Platform. It provides features such as granular verification logs, metrics to track verification traffic, and built-in rate limits for international revenue sharing fraud prevention. The new API also includes stronger transaction verification for PSD2 compliance and supports public key client validation or scoped API keys for secure integration. A public beta version is now available, with some features still under development and others subject to change before general availability. Existing Verify v1 users can easily migrate to the new API by updating their code and endpoints.

This post provides a step-by-step guide on creating an Azure function in C# that sends a daily dog picture via WhatsApp using the Twilio API. The author assumes some base knowledge of C# and RESTful APIs, and outlines the necessary steps to create an Azure Function App, add dependencies, call a Dog API to retrieve a photo, and send the returned image to a phone number via the Twilio API for WhatsApp. The guide covers updating the Azure function's configuration file, adding environment variables for the Twilio Account SID and Auth Token, and creating a new method in the run.csx file that fetches an image from the Dog API and sends it using the Twilio API for WhatsApp.

The Twilio Client JS SDK 1.7 has been released with support for Opus, a codec that delivers better audio quality in various network environments, compared to the current supported codec G.711 (PCMU). The new Codec Preference API allows developers to control which codecs to use and set Opus as the preferred codec. This release enables superior voice quality at less than half the bandwidth required by G.711, making it a recommended upgrade for Twilio Client JS users.

Twilio Flex is disrupting the contact center landscape by offering a fully programmable platform that allows customers to design and manage a customized contact center tailored to their unique business model. The platform's flexibility and scalability are seen as a threat to traditional, pre-packaged software solutions, which are perceived as inflexible and limiting. Twilio's approach is centered around collaboration between line of business owners and web developers to create new and different ways to interact with customers. The company's platform has already gained traction, with notable clients such as Lyft, and is expected to continue accelerating the shift away from legacy contact center solutions.

Twilio's API allows users to send and receive media, including images, using WhatsApp. The application will use AWS Rekognition to analyze the images sent by users. The application is built using Ruby and Sinatra, with Twilio-Ruby for generating TwiML responses. Ngrok is used to tunnel down to the local machine from the public internet for testing purposes. The application downloads the image received via WhatsApp, analyzes it using AWS Rekognition, and responds back to Twilio with a message indicating whether any celebrities were detected in the image.

Twilio has announced that its SMS feature is now available on the Salesforce AppExchange, a platform that allows businesses to easily find and install third-party apps. The Twilio for Salesforce app provides a simple way for organizations to integrate SMS into their communication workflows using Salesforce, enabling features such as triggering or sending alerts, engaging in 1:1 text messaging with contacts and leads, and sending messages to large audiences using campaigns. The app is designed to be easy to use and familiar, with components that integrate well with both Lightning Experience and Salesforce Classic, and it offers a range of straightforward features such as real-time 1:1 SMS/MMS communication, broadcast messaging, and message deliverability status reporting. The app also provides flexibility for custom integrations using the included Apex API library, allowing developers to make API calls to Twilio's other communication channels and server-side developer tools.

Twilio has announced the General Availability of its Voice Dialing Geographic Permissions REST API, allowing developers to automatically enable dialing permissions for new trial users based on their country. This feature aims to improve international conversions by providing a low-friction experience for users. To configure permissions, developers can use the REST API to update country-specific settings, such as enabling or disabling calling to high-risk destinations. The API is available for free and can be used across all Twilio projects and subaccounts. Developers can also use the Console debugger to monitor warnings related to calls blocked by Geo Permissions due to Programmable Voice or Elastic SIP Trunking. To reduce toll fraud risk, developers can update country-specific settings using a script that disables high-risk destinations in each supported country.

To deploy a static site with Netlify and send text messages using Twilio, you need to create a serverless function that can react to form submissions. The function will use the Twilio helper library to send SMS messages. To do this, you need to define sensitive information like your account SID, auth token, and phone numbers in an environment file (`.env`), which should be excluded from version control using `.gitignore`. You also need to install the `netlify-lambda` package and define a build configuration that includes the serverless function directory. Once deployed, you can trigger the function by submitting the form on your static site, and it will send an SMS message to the specified recipients.