May 2018 Summaries

The design patterns of MVC (Model-View-Controller) and MVVM (Model-View-ViewModel) are both used in iOS development for managing the interaction between a user interface, business logic, and data. The main difference is that MVC separates the UI logic from the business logic by using a controller to manage the flow between the view and model, whereas MVVM uses a view model as an intermediary to separate the UI logic from the business logic. Both patterns aim to improve code readability, testability, and maintainability. By migrating from MVC to MVVM, developers can achieve more decoupling of concerns, making it easier to debug, test, and read code. The process involves identifying UI logic and business logic in existing code, creating a view model to handle the business logic, and then updating the controller to interact with the view model instead of directly accessing the model. This approach allows for more flexibility, reusability, and maintainability in iOS development.

To programmatically download an image from an MMS message sent to a Twilio number, developers can use Node.js and the Twilio MMS library. The process involves creating an Express app that receives HTTP requests from Twilio when a text message is sent to the designated phone number. The app then uses the `request` module to download the images contained in the message and save them locally. To test this setup, developers need to create a Twilio account, buy a phone number, install the necessary dependencies, and use tools like ngrok to expose their local app to the public internet. This setup enables developers to receive images via text messages from users and can be used as a starting point for larger projects that involve image manipulation or processing.

With the advent of personal digital assistants and in-home, voice-controlled gadgets, voice technologies are on the rise. Building an implementation of Twilio’s Automated Speech Recognition (ASR) service in a simple Ruby on Rails Application enables developers to see the wide-reaching possibilities for other implementations in their own projects. The tutorial focuses on creating a "Feedback Service" that receives, responds to, and stores voice messages from user phone calls—using speech recognition—and then displays them for review at a later time.

You're building a Vapor app to respond to SMS messages using Twilio, and here's how you can set it up with Swift Package Manager. First, install Vapor and its dependencies using the Swift Package Manager. Next, create a new Swift project and add the Vapor package to your `Package.swift` file. Then, write some Swift code to handle HTTP requests and responses. To receive text messages, you'll need to configure your Twilio account and use ngrok to make your app visible from the Internet. Finally, add an SMS route to your app to handle incoming text messages and respond with a custom message using TwiML. With this setup, you can build a Vapor app that receives and responds to text messages using Twilio.

Twilio has updated its API documentation to include new annotations that clarify what personally identifiable information (PII) fields are and how they should be handled for GDPR compliance. The annotations provide guidance on data storage, retention, and protection, and explain why certain fields are considered PII while others are not. For example, Twilio SIDs are marked as "not PII" because they don't require technical protection or redaction, while phone numbers may be treated as PII if used to identify end-users. The goal is to empower developers to make informed choices about how to manage customer data and ensure GDPR compliance in their applications.

Introducing Enterprise Admin Center, a new capability that brings together all Projects within an organization, providing centralized administration for Twilio assets and reducing operational risk. The feature addresses concerns around compliance requirements by consolidating all Projects into one Organization, allowing designated admins to perform management actions such as adding & removing users, viewing app Projects, and updating Project settings.

While the May 25 deadline for GDPR has passed, not being fully compliant may still have consequences. The regulators may give credit for efforts made, but customers may be more critical. Companies with EU operations or customers in the EU are generally bound by GDPR regulations. Even US-based companies that don't have EU operations can face scrutiny if they knowingly serve EU customers. Ensuring vendors processing EU personal data comply with GDPR is also crucial, which can be achieved through signing a Data Protection Addendum. Understanding and implementing these measures is essential to protect against potential issues.

A cellular connected portable fax machine was built using a Raspberry Pi, thermal printer, and Twilio services. The project requires a Twilio account, Programmable Fax service, LTE USB modem, and other hardware components. The software uses Node.js, Vue.js, and Twilio Sync to manage faxes and send them to the printer. The process involves setting up the Raspberry Pi, connecting the thermal printer, configuring Twilio services, hosting the backend, and running the fax client software using Node.js. Once set up, users can send faxes to the printer via the Faxes API and receive updates in the web dashboard. The project is a fun example of IoT development and can be expanded upon with additional features such as camera integration for taking photos and sending them out to another fax machine.

Centrifuge, developed by Twilio Segment, is a robust system designed to deliver billions of messages daily to numerous public APIs, addressing challenges such as endpoint failures, latency spikes, and rate limiting. Traditional queueing systems proved inadequate due to their limited operations and inability to handle high-failure environments efficiently, prompting the creation of Centrifuge as a fully distributed job scheduler that offers message delivery, retry capabilities, and message archiving. The system employs a unique architecture that isolates message queues per source-destination pair, allowing for dynamic throughput adjustments and efficient error handling without excessive data copying. Centrifuge utilizes Amazon RDS with MySQL for its data model, which supports immutable rows and avoids complex database operations, enabling efficient message reordering and delivery management. The Director service manages job execution, caching, and database interactions, ensuring fast, reliable message processing even under high-load scenarios. Centrifuge's architecture allows it to scale dynamically with traffic, supported by a JobDB Manager that adjusts the number of databases to match the compute layer, ensuring efficient data handling and minimal delays. The system's effectiveness in handling high-failure scenarios was demonstrated during a significant third-party API outage, where it successfully managed to absorb and deliver a massive volume of events without data loss or significant customer impact.

The Recording Compositions API is now available in Public Beta, enabling developers to transcode, combine and mix Group Room Video Recordings through an API. The API solves the problem of mixing individual recorded tracks, which requires synchronization, transcoding, scaling and layout operations. To create a composition, developers need to specify sources, video layout, resolution and other parameters, and the media engine applies processing and transformation operations to generate a new composed media file. The API is designed with simplicity and predictability in mind, with pricing based on composition duration and storage costs per GB and month. Future updates will include console controls for automating composition creation, searching and visualizing compositions, as well as support for further media formats.

To receive a POST request with server-side Swift using Vapor, you need to create a Codable struct to map the data from the request body and then use this struct in your route. After setting up your project with Swift Package Manager and Vapor, you can add routes for GET, POST, and other types of requests. To handle incoming POST requests, you'll need to decode the request body using your Codable struct. You can test your application by running `curl` commands or using a tool like ngrok to expose your local server to the internet. Once set up, you can use Vapor to create powerful backend APIs for your iOS apps and other applications.

User Secrets in .NET Core provide a secure way to store sensitive data outside of the project tree, making it easier to manage configuration and secrets for development teams. By using User Secrets, developers can avoid sharing sensitive data on GitHub or other public repositories, reducing security risks. The process involves adding User Secrets to the project, storing them in a JSON file outside of source control, and mapping them to C# models for type safety and testability. With User Secrets, developers can decouple their code from sensitive data, making it easier to maintain and update configuration settings across multiple projects and environments.

User Secrets are stored outside of the project tree in a JSON configuration file in the user profile directory and are therefore outside of source control, providing flexibility and security for managing sensitive data. User Secrets can be shared across multiple projects via their GUID or even different sets of User Secrets for each branch of your solution. The best way to consume user secrets is by mapping them to a model, which provides type safety and prevents errors from misspelt string names. .NET Core's built-in dependency inject allows injecting the secrets into the constructors of classes and services via the IOptions<> interface.

Sonic Pi is an Integrated Development Environment (IDE) for writing music in Ruby. It allows users to interact with their computer as if they were using a synthesizer, and can be used to create complex electronic music compositions. The basic syntax of a loop in Sonic Pi involves naming the loop, calling in a synth or sample, and adjusting the timing with sleep. Users can add multiple loops to create a full sound, and also use effects such as distortion to modify the sound. Additionally, users can play notes using the `use_synth` method, and add audio samples to their composition. The IDE has a built-in documentation feature that allows users to experiment and learn from examples. With its user-friendly interface and powerful features, Sonic Pi is an ideal tool for musicians and music producers looking to create complex electronic music compositions.

The latest version of Microsoft Edge supports screen capture, allowing developers to access a user's screen stream without the need for extensions or manual configuration. This feature is part of the EdgeHTML engine version 17 and follows the proposed W3C spec for screen capture. To use this feature, developers can call the `getDisplayMedia` function, which returns a promise that resolves with a stream of the screen. The user is prompted to choose whether to display their application or desktop, making it easier than other browsers' approaches. Edge requires serving the HTML file on HTTPS to access this API, and ngrok can be used to sidestep self-signed certificate issues.

You can receive SMS messages into Google Sheets using Twilio's APIs and Apps Script. To start, remove the automatic reply message from your Twilio phone number by configuring the TwiML settings in the console. Then, set up a new Google Spreadsheet to download and read your messages. Copy and paste the sample script into the spreadsheet's Script Editor, update it with your Twilio account information, and run the script to retrieve your SMS messages. The retrieved data can be organized and sorted as needed in another spreadsheet for organizational purposes. This solution allows users to receive SMS messages separately from their personal mobile phone number and easily manage and organize them using Google Sheets and Apps Script.

To build a real-time chat application with Django and Twilio Programmable Chat, developers need to consider several concerns such as user modeling, channels, access levels, and message display. The process involves setting up a virtual environment, installing dependencies, creating a new Django project, and configuring the Twilio Chat service. Developers can then create views to fetch data from the database and templates to render the chat interface. To enable live chat functionality, developers need to add endpoints for token generation, channel creation or joining, message sending, and pagination. The app also needs to be tested with sanity checks to ensure that it functions correctly. With this guide, developers can build a basic chat application using Twilio Programmable Chat and Django, and explore more capabilities of the API.

A developer built a real-time chat application using Twilio Chat and lit-html, a templating library for web applications. The chat application allows users to send messages in real-time and updates the UI efficiently using lit-html's browser-native functionality. The application uses code-splitting with Parcel to improve page load time by only loading necessary code on initial page load. The developer also generated an access token dynamically using Twilio Functions, a serverless function service, to authenticate users before starting the chat session.

The author, Stuart Logan, created an app to host a Eurovision party with a sweep where attendees would be randomly assigned a country and bet on the outcome. He used web scraping techniques using Python's `requests` and `beautifulSoup` libraries to gather information about the participating countries and their corresponding Wikipedia links and Eurovision voting pages. The scraped data was then stored in a JSON file, which was uploaded to Twilio Functions as a Private Asset. A lightweight event-triggered Function was created to accept an SMS containing the number of attendees and return a random country for each person via SMS. The Function was deployed and connected to a phone number, making it available across Europe and Australia for attendees to participate in the sweep.

To programmatically download an image from an MMS message sent to a Twilio number using Python and Flask, one needs to have the Twilio Python helper library installed, as well as the Flask framework. A globally accessible URL is required for Twilio to send a webhook request when a message is received, which can be achieved by using ngrok to open a tunnel to a local machine. The code consists of a Flask app object with one route that responds to incoming messages with a simple text message and downloads an image if present, saving it to a specified directory. Twilio expects an HTTP response in the form of TwiML, which is generated by the Flask app's response. To test this setup, one needs to create a Twilio account, buy a phone number, navigate to the code directory, install dependencies, copy and paste the provided code into a file called `app.py`, replace the `DOWNLOAD_DIRECTORY` variable with the desired path, and point the phone number at the app's URL.

The fight for net neutrality is a critical issue that determines the future of the internet and society, with Fight for the Future playing a key role in capturing and amplifying people's voices to make real change. The organization built a powerful tool using programmable voice and SMS technology to connect constituents directly to their lawmakers, resulting in millions of calls and texts being made during the public comment period on net neutrality protections. This grassroots effort has generated significant support for net neutrality across both sides of the aisle, with elected officials acknowledging the impact of constituent voices on their decisions. Despite the FCC's initial vote to roll back net neutrality protections, the fight continues, with Fight for the Future advocating for a concrete strategy to overturn the decision and restore net neutrality.

Creating a Jenkins server for managing deploy processes provides consistency, incorporates tests, and protects the production server. To achieve this control, using a managed service like GitHub's GitLab can be opaque and outside one's control. Instead, a dedicated Jenkins server offers total access and control over the deploy chain. This setup allows users to create jobs that handle deploy processes for projects, triggered by commits to their GitHub repositories, ensuring integration checks happen every time.

The U.S. Senate is scheduled to vote on preserving net neutrality protections, which could have a significant impact on the preservation of an open and accessible internet. The fight to preserve net neutrality is far from over, with innovators and small businesses playing a crucial role in shaping the outcome. Twilio is urging its users to contact their Senators to express support for preserving net neutrality, while also continuing to work with Congress and regulatory bodies to ensure transparency and certainty in communications.

GDPR, or the General Data Protection Regulation, is a European Union law that regulates the processing of personal data. The regulation imposes strict rules on businesses that collect, store, and process EU citizens' personal data, regardless of where they are located. However, GDPR does not outright prohibit the transfer of personal data outside the EU. Instead, it requires businesses to ensure that such transfers comply with GDPR's principles, which can be achieved through various means, including binding corporate rules, standard contractual clauses, or participating in recognized transfer mechanisms like the EU-US Privacy Shield framework. Twilio, a cloud communication platform provider, often receives questions about data locality under GDPR and has clarified its stance on this topic, emphasizing that it complies with GDPR's requirements for cross-border transfers and offers various safeguards to ensure data protection.

Apple introduced Auto Layout to help developers create adaptive interfaces that respond appropriately to changes in screen size and device orientation. By mastering Auto Layout, developers can create apps that look good across all devices. The tutorial covers the basics of Auto Layout, including its importance, different sections on Xcode, using auto layout in the interface builder, auto layout and constraints, the Auto layout menu, resolving layout issues, examining and editing constraints, and debugging. It also introduces Stack Views, which provide a streamlined interface for laying out views in columns or rows. With this tutorial, developers can learn how to create adaptive UIs that fit multiple screen sizes.

To build a server-side Swift application that plays Pokémon using text messages, you'll need to install wine, Vapor, and a Windows Visual Boy Advance emulator with Lua scripting capabilities. You'll write Lua code that reads from a file called "button.txt" on every frame of the game and writes to it based on button presses received via text messages. Then, you'll create a new Vapor project and add a route to receive SMS messages to your Twilio number for button presses. With ngrok, you can make your app publicly accessible and configure your phone number to start receiving text messages from friends who want to play Pokémon with you.

The use of weak passwords is a significant problem in password security, with many people reusing passwords across multiple accounts, making them vulnerable to credential stuffing attacks. The National Institute of Standards and Technology (NIST) has updated its guidelines for password security, recommending against arbitrary change requirements, forcing special characters or uppercase letters, and disallowing compromised passwords. To improve security, experts recommend using a password manager and enabling two-factor authentication, which adds an additional layer of protection in case the first factor is compromised. By adopting these best practices, individuals can significantly reduce their risk of identity theft and protect themselves from hackers.

The Bike Project` is a UK-based charity that aims to provide affordable transportation to refugees. Founded by Jem Stein, the organization delivers hundreds of bikes to those in need every year, saving them thousands of pounds on public transportation costs and providing freedom and independence to travel at will. To manage the high demand for their services, The Bike Project has developed a queueing and notification system that integrates with their existing CRM, utilizing Twilio SMS to send automated notifications to users when bikes are ready. With a team of 14 staff and volunteers, they also provide additional support to refugees after receiving a bike through initiatives like `Bike Buddies` and `Pedal Power`. The organization is expanding its operations to Birmingham, with the goal of getting every refugee on a bike.

### Summary of the text delimited by triple backticks``` We learned how to create routing in an Angular Single Page Application (SPA) with JavaScript and Node.js. We covered the basics of routing, including navigating between components, using path and query parameters, prefetching data with resolvers, creating lazy loaded modules, and error handling. We also discussed how to use lazy loading to split the application into smaller chunks and load them on demand when the user navigates to different parts of the app. The goal is to improve the user experience by reducing the initial load time of the application.

Layla Porter, a former Pilates teacher and studio owner, had a career change from marketing to software engineering in 2013 after her father's sudden passing. She built a bespoke online booking system for her studio using a custom website and later transitioned into web development. With the help of online resources like FreeCodeCamp and Microsoft Virtual Academy, Porter dedicated herself to learning frontend technologies for eight months while still teaching Pilates full-time. After feeling ready, she applied for junior developer roles and was eventually hired at a local digital agency in 2016. She now serves as a Developer Evangelist at Twilio, where she mentors junior developers, volunteers with women's coding groups, and encourages people to get involved in the .NET community. Porter's journey showcases her perseverance, determination, and passion for learning and sharing knowledge with others.