June 2018 Summaries

Apache Spark is a distributed data processing engine that aims to solve the problem of working with large-scale distributed data. In this tutorial, Plushcap and Kelley Robinson explore how to get started with Apache Spark by analyzing pwned passwords, which consist of over 500 million leaked passwords. The authors use Apache Zeppelin as an interactive web application notebook for creating and running Spark applications, including reading in CSV data, viewing schema information, and performing data analysis using SQL. They also demonstrate how to work with Datasets, a new abstraction introduced recently to the Spark project, and explore common password lengths and patterns using Spark SQL functions. The tutorial provides a comprehensive introduction to Spark and its tools for working with distributed data, making it an excellent resource for developers and data analysts interested in learning more about Apache Spark.

A reusable iOS component is built using Swift to provide a more efficient and maintainable way of structuring the code for an iOS application. The process involves creating a model, a table view controller, and a rating view as separate components that can be reused throughout the app. The reusable components are created by employing techniques such as composing types, nib files, and delegate patterns to make them more versatile and maintainable. These components can be easily integrated into an existing iOS application or used as a starting point for building new ones. By following this approach, developers can reduce code duplication, improve the overall structure of their app, and enhance its performance and user experience.

Twilio's Elastic SIP Trunking now supports blind call transfers, allowing users to initiate a call transfer by sending a SIP REFER message. This feature is enabled on a per-Trunk basis and can be used to transfer calls between agents in different locations. The process involves sending a SIP REFER message from the user's SIP communications infrastructure to Twilio, which then handles the call redirect, freeing up resources in the IP communications infrastructure. To start using this feature, users need to log into the Twilio Console, navigate to an existing Elastic SIP Trunk, and enable Call Transfers under General Settings. Once enabled, users can initiate a transfer by placing a call via their Elastic SIP Trunk and sending a transfer request, which Twilio will then handle according to the call flow that includes a SIP REFER message, a 202 Accepted response from Twilio, and subsequent SIP INVITE and NOTIFY messages.

This article describes how to build a camera switcher into a video chat application using Twilio Video. The author starts with a modified version of the Twilio Video quickstart application and adds functionality to enumerate devices, display a dropdown list of cameras, and switch between them during a call. The code is written in JavaScript and uses the mediaDevices API to interact with the user's camera. Once the camera switcher is implemented, users can join a video room, preview themselves, and switch between cameras using a dropdown list. The article also discusses potential use cases for this feature, such as showing surroundings or switching between front and rear cameras for face-to-face calls.

This article provides an introduction to installable web apps, also known as Progressive Web Apps (PWAs), using JavaScript and Node.js. The author starts by cloning an existing PWA and adding a service worker script that enables offline functionality. To make the app installable, it adds a web app manifest and uses Workbox to generate a service worker script automatically. This process allows for faster updates of assets and reduces bandwidth usage. The article also covers how to add icons to the manifest file using an online tool and provides instructions on how to deploy the app to a hosting service.

The Configuration Deployments system at Twilio enables top-level configuration as part of a deployment, decoupling runtime configuration from built artifacts. This allows for predictability, resilience, velocity, and improved engineer experience. The system provides type safety, schema validation, and auditability to application configuration, bridging the developer experience between deploying software to containers and virtual machines. It ensures high availability, allowing for quick, safe, and easy rolling forward or back of configurations during incidents. Application developers create a JSON Schema Specification file to define required configuration values, which are then deployed along with software. The system provides multiple means of accessing configuration, including Chef, HTTP servers, and environment variables, to support various workflows and applications.

You can quickly customize call flows with Twilio Studio and TaskRouter to receive calls on your Twilio phone number and put callers into a call queue while they listen to music until an agent is available. Agents use their web browser to manage their status and are connected with the caller using their computer, microphone, or Twilio Client. To implement this, you create a TaskRouter workspace, configure a TaskQueue and Workflow, deploy an agent application, and set up an IVR in Studio to welcome callers and put them into the queue. You also need to buy a Twilio phone number and test the application to ensure it's working correctly. Once implemented, you can scale your call center by adding more workers, queues, and features like timeout and escalation logic.

A developer uses Blazor, a new experimental framework that allows building web applications using HTML, C#, and WebAssembly, to create a simple web page that makes telephone calls straight from the browser with C# and Twilio. The project starts by setting up tools such as .NET Core 2.1 SDK, Visual Studio 2017, Blazor, and a Twilio account and phone number. A new Blazor application is created, and a component is built to make a phone call when someone clicks on a button. This involves using the Twilio REST API to create an HTTP request that makes a phone call to the user's cell phone, which then forwards the call to the destination number specified in the URL. The project concludes by highlighting the potential of Blazor and its experimental nature, recommending further learning resources for those interested in exploring this technology.

The article describes how to create a Flask app with Python that uses Contentful's content delivery API and Twilio's Programmable SMS API to support space travel. The app will provide instructions, maps, and fan messages to astronauts on their way to Mars. The app uses localization to display instructions in the astronauts' native languages. The article covers how to create a Flask app with four routes: one for general information, one for exosphere instructions, one for spacemap, and one for sending fan messages via SMS. It also explains how to use Contentful's Image API to reduce image payload size and Twilio's Programmable SMS API to send text messages.

A model Intelligent Transportation System (ITS) is developed to manage emergency vehicles at traffic intersections using a combination of Python, LoRa, MQTT, and Twilio Sync. The system employs a Raspberry Pi 3 to control traffic signals and a simulated GPS device to track emergency vehicles along a predefined route. Twilio Sync acts as a cloud-based orchestrator, allowing seamless communication between connected devices to ensure traffic lights turn green for approaching emergency vehicles. In addition to internet-based communication, LoRa provides a backup point-to-point connectivity to ensure reliability in case of network failures. The ITS demonstrates how smart city applications can enhance urban infrastructure by facilitating the efficient movement of emergency vehicles, thereby potentially saving lives and reducing property damage during crises.

Troy Hunt's Pwned Passwords API has released version 2, featuring more compromised passwords and improved query security. In response, the developer community has created libraries in seven programming languages to check for pwned passwords: Ruby, Python, Java, PHP, Node.js, C#, and Go. These libraries provide a convenient way to verify password safety and prevent credential stuffing attacks. By using these libraries, developers can help protect users from potential security breaches and promote better password hygiene.

The Coin Alert app is a Node.js application that tracks cryptocurrency prices and sends SMS alerts when a coin's price crosses a set threshold. The app uses Express, MongoDB, Twilio, and Agenda to retrieve data from the CoinMarketCap API, store it in a database, and schedule tasks to run at regular intervals. By following this tutorial, developers can create their own version of the Coin Alert app, which can help them stay informed about cryptocurrency prices without constantly checking the markets.

The author, Kelley Robinson, created a bot to keep her mom updated on her travel schedule using Python, Twilio, and Google Calendar. The bot uses the Google Calendar API to access her calendar and Twilio SMS to send messages. The code creates a Flask server that responds to incoming SMS messages by checking if the user asked for their current location or travel schedule. If not, it responds with a help message. To set up the bot, one needs to create a service account, enable the Google Calendar API, and install dependencies such as Flask, Twilio, and OAuth2client. The author also uses ngrok to make the application accessible on a public port for Twilio to connect to.

Twilio Functions can be used to add custom JavaScript code to Twilio Studio flows, allowing for more complex routing and decision-making. A Studio Run Function widget calls a Twilio Function, which compares the current time of day with business hours and returns a result, "open" or "after". The Split widget then routes the call based on this result. This combination gives Studio more power to route calls to various destinations. By integrating a Twilio Function into a Studio flow, users can create intelligent call forwards with logic-driven routing. Configuring a Twilio phone number to use the flow allows for testing and deployment of these complex flows.

To set up a continuous delivery system with Jenkins and GitHub, create a new server for deployment and configure it to work with Jenkins. This involves creating a new user on the deployment server, installing an SSH plugin in Jenkins, and setting up credentials for the repository. Next, create a new job in Jenkins that triggers on commits to the repository, builds and tests the code, packages the build, and deploys it to the server. The job can be customized to include additional steps such as restarting services and updating environment variables. Once the job is set up, it can be triggered by commits to different branches, allowing for automated deployment of test, staging, and production versions of the application.

The tutorial starts by explaining the importance of linear algebra and statistics in data science and software engineering. It then introduces Python as a tool to apply statistical concepts computationally, specifically using NumPy and SciPy. The guide covers vectors, matrices, and NumPy's support for these data structures, including how they can be used to manipulate images and text data. The tutorial also touches on sentiment analysis using machine learning algorithms from scikit-learn, which relies on SciPy's data structures. Throughout the tutorial, Jupyter Notebooks are emphasized as an ideal environment to interact with code, and basic operations such as saving, adding, and running cells are reviewed.

To handle incoming phone calls with Twilio Programmable Voice, developers can use Swift Package Manager to set up their Vapor app. They need to install dependencies, including Vapor, and configure their package file to include it. Next, they create a basic "Hello World" application using Vapor's command line tool. To receive calls, they need to initiate ngrok for a publicly accessible URL to their app. Once configured, Twilio sends POST requests to the /call route on the Vapor app, which responds with TwiML telling Twilio to play a sound file over the phone call. The process involves setting up a Twilio account, configuring the ngrok URL, and writing code to handle incoming calls using Swift and Vapor.