February 2020 Summaries

Stream Flutter is a tutorial series that guides users in creating a simple social networking app where users can post messages and chat with followers, utilizing Stream's Activity Feed and Chat API along with Google's Flutter framework. The project is fully functional on both iOS and Android, with the source code available on GitHub, and focuses on implementing complex interactions in a straightforward manner. Although the tutorial mainly demonstrates the Android implementation, corresponding iOS code is available for reference. The series is divided into three parts: Activity Feeds, Messaging, and Group Channels, and is supported by a comprehensive Flutter SDK tutorial to help users quickly get started with Flutter.

This tutorial outlines the process of building a real-time chat application using Angular 9 and Stream Chat, providing a step-by-step guide to setting up channels and sending messages. It details the prerequisites, such as installing Node.js, npm, and Angular CLI, and offers instructions on creating an Angular app, setting up a server with Express, and handling user authentication with Stream Chat tokens. The tutorial also covers building the chat interface using HTML and CSS, and implementing the logic for message handling and channel management in Angular. Additionally, it highlights the use of Stream's event capabilities to update the chat UI in real-time and provides guidance on querying channels and sending messages. The tutorial concludes by encouraging further exploration of Stream Chat's features through its documentation and offers a GitHub repository for accessing the complete code.

The tutorial series on building a full-stack application with Flask and Stream progresses by introducing an infinite scroll feature for collections and content using JavaScript to retrieve information from the Stream API client-side. This installment emphasizes the integration of client-side requests, which circumvent the need for server proxying, and focuses on the generation and management of user authentication tokens to secure data access. It details the steps to create user feeds and collection feeds, using templates to ensure consistency across the site and employing a JavaScript library to facilitate resource access. The implementation of infinite scroll, a common feature in modern social media, is highlighted as a user-friendly alternative to pagination, with specific instructions for setting up intersection observers and handling data requests efficiently. The tutorial also touches on maintaining visual consistency with shared templates and prepares readers for future enhancements such as user following and customized activity feeds.

The post outlines the creation of a simple social network app named Stream Flutter, which allows users to post messages to their followers using Google's Flutter framework and Stream's Activity Feed API. The application is designed to function on both iOS and Android, though the examples primarily focus on Android. It involves building a mobile app with Flutter and a backend using Express (Node.js) to handle user registration and token generation for secure API interaction. Users can log in, post messages, and follow others to view a combined feed of messages from those they follow. The tutorial provides code snippets and explanations for key functionalities, such as logging in, posting messages, and managing user timelines, with further details available in the source code on GitHub. The app leverages platform channels to connect Flutter with native Java and Swift libraries for interacting with Stream's REST API, highlighting Flutter's capability to build cross-platform mobile applications efficiently.

The text outlines the process of implementing direct messaging between users in a mobile application using the Stream Messaging Platform, building on a previous tutorial. It describes how to modify the backend to generate a Stream Chat frontend token, which authenticates the client application directly with the Stream Chat API. The tutorial involves integrating Stream Chat libraries into a mobile application built with Flutter and utilizing native Android and iOS libraries. Users can navigate a list of other users, select one to chat with, and engage in 1-on-1 conversations where messages are sent and received through the Stream API. The text also details the setup and management of channels, the creation and sending of messages, and the display of messages in a chat interface. The integration leverages Platform Channels for communication between Flutter and native code, and the tutorial is intended for those with a basic understanding of Node.js, Flutter, Kotlin, and optionally Swift. Finally, it suggests further enhancements like using Stream's out-of-the-box views and notes the ongoing development of a pure Dart library by Stream.

In the third part of a series on building a social application, the focus is on integrating group chat functionality using Stream Chat within a Flutter-based mobile app. The backend infrastructure, previously set up in parts one and two, provides the necessary tokens for the Flutter app to interact with the Stream Chat API directly, eliminating the need for additional libraries beyond the existing Stream Chat Android and Swift libraries. The process involves setting up user navigation to chat channels, creating new channels, and enabling real-time message exchange through the app. The app uses Flutter's Platform Channels to handle communication with native code in Kotlin or Swift, facilitating message broadcasting and event handling. Users can create, send, and view messages in group chats, with a simple, flexible layout that includes message input, submission, and display features. The app supports retrieving and listing available channels, allowing users to join and chat within any existing channel. The integration relies heavily on Stream's libraries to manage API communication, ensuring seamless chat functionality.

The tutorial outlines the process of creating a chat application using PHP for the backend and JavaScript for the frontend, leveraging the Stream API for real-time communication. It begins by explaining the prerequisites, including the need for PHP, Composer, and a basic understanding of PHP and JavaScript. Users are guided through setting up their environment, including downloading a sample app from GitHub, creating a Stream account to obtain API credentials, and structuring a PHP project with specific files for server logic, UI, and styling. The tutorial details how to generate user tokens with the PHP SDK and integrate the JavaScript SDK for real-time updates and message handling in the chat interface. It further elaborates on initializing the chat client, managing user authentication, sending, and receiving messages, and setting up the chat UI. Users are encouraged to test the app by running it on a local server and experimenting with different browser sessions to exchange messages. The tutorial concludes with suggestions for adding advanced features like typing indicators and user presence to enhance the chat experience.

Homeis is a digital platform designed to support foreign-born communities by connecting immigrants with those who share their cultural backgrounds, offering a social network that includes a social feed, chat, and discussion groups, as well as practical resources such as real estate and job markets. With over 200,000 users across six national communities, homeis aims to be a comprehensive resource for expatriates. To enhance its chat and feed functionalities, homeis partnered with Stream, leveraging its SDKs compatible with their tech stack, including React and Node.JS, to overcome previous stability issues and quickly deploy an efficient solution without excessive resource investment. This partnership has allowed homeis to scale its chat capabilities significantly, contributing to a 1000% growth in chat usage. As part of its future vision, homeis intends to expand its platform to include more nationalities within the United States and eventually extend its reach globally, helping immigrants integrate into new environments while maintaining their cultural roots.

In the seventh installment of a tutorial series on building a full-stack application with Flask and Stream, the focus is on managing activities like creating, updating, and deleting content within collections, which are groups of URLs with previews. The process involves setting up a database table to store content details, ensuring no duplicate entries, and constructing class functions for content management. Forms are built to interact with the database, using select fields populated with user collections, which are coerced into integers to match database requirements. Templates are designed for adding, editing, and viewing content, with permissions checks integrated to control editing access. The tutorial also emphasizes the importance of testing, including creating, updating, and deleting users and collections, while ensuring tests do not interfere with real data. The installment concludes with anticipation for the next article, which will cover integrating Stream client-side with JavaScript and infinite scroll.

Creating a chat application with real-time notifications becomes significantly easier using Stream Chat, which offers built-in capabilities to display notifications for various actions. The guide demonstrates how to set up a React-based chat application that leverages Stream Chat to notify users of new messages, using Node.js and npm for setup and Express for server-side operations. It explains how to prompt users to enable browser notifications and how to listen for message events to trigger these notifications, including changing the browser's favicon to indicate unread messages. The tutorial provides detailed instructions on integrating Stream's React components to build a responsive chat interface with features like typing indicators and emoji reactions, while also ensuring that notifications are displayed when new messages arrive. The application utilizes a random username generator to simulate multiple users and simplify the testing process, illustrating how to create a functional chat application with minimal code and highlighting the ease of extending functionality with Stream's comprehensive documentation.

This tutorial provides a detailed guide on building a Twitch-style application using Stream Chat's "livestream" functionality, which integrates video streaming with a chat feature. The process involves setting up a server using an open-source API and developing a client using React Native, requiring a Stream account and MongoDB. The application consists of an authentication page and a video and chat page, where users can log in or register and engage in a chat while watching a video. The tutorial includes instructions for setting up the development environment, configuring the server, and building the client, with the source code available on GitHub for reference. Suggestions for enhancing the app, such as implementing live video streaming, are also discussed.

Self-destructing or ephemeral messages are a popular feature in chat applications, automatically erasing messages shortly after they are sent to ensure no lasting record remains. This tutorial guides users through implementing such a feature using the Stream Chat API within a React application. It requires users to have Node.js and yarn installed, and some familiarity with React. The tutorial involves setting up a React application, configuring an Express server to handle message deletion and user authentication, and implementing the frontend to allow messages to self-destruct after a set time. This is achieved by listening for new message events and using the Stream Chat API to delete messages after a specified timeout, ensuring the feature is only triggered by the message sender. The tutorial encourages exploring further customization options, such as configurable message timeouts, and offers additional resources for learning more about the Stream platform.

The sixth installment of the tutorial series on building a full-stack application using Flask and Stream focuses on creating, updating, and deleting activities on Stream, as well as enriching feed activities. The tutorial introduces the concept of Collections, which are user-created objects to store URL links. It guides users on integrating the Stream API into their applications, highlighting its ability to store and retrieve feed and chat objects with low latency. The post also covers setting up user registration with enriched data, managing changes in the user database, and creating a Collection model to store user links. It provides instructions for creating, retrieving, editing, and deleting collections, emphasizing the importance of handling API requests within class functions for better exception management. The tutorial concludes by outlining the steps to construct views and templates for managing collections and previews the next tutorial on adding content to collections.

The post provides a comprehensive guide for building a simple group chat application using Vanilla JavaScript and Stream Chat, a tool that simplifies the implementation of real-time messaging systems. It begins with instructions on setting up a Stream account and acquiring the necessary API key and secret for authentication. Users are guided through setting up a basic HTML and CSS user interface, followed by integrating functionality using the Stream Chat NPM module and Browserify for bundling JavaScript files. The guide details the creation and configuration of a chat client, setting up channels, sending messages, and handling events like 'typing' and 'new message' notifications. It also illustrates how to load historical messages and display them in a user-friendly format. Additionally, the post explores creating a user registration system using an open-source API with MongoDB for storing user data, encouraging developers to expand the application's functionalities further. The tutorial concludes by highlighting the potential of Stream Chat in developing more complex applications and directs readers to additional resources for further exploration.

In a discussion between Max Lynch, CEO of Ionic, and Thierry Schellenbach, CEO of Stream, they explore the nuances of building mobile applications using Ionic compared to platforms like Flutter and React Native. Ionic stands out for its use of open web technologies, allowing developers to maintain a single codebase for both web and mobile applications, thus adhering to the DRY (don't repeat yourself) principle. In contrast, Flutter and React Native provide a closer-to-native application feel but require separate codebases for different platforms. The blog post then provides a detailed tutorial on creating a real-time chat application using Ionic, React, and Stream's API, illustrating the setup process, including the installation of necessary tools like Node.js, XCode, or Android Studio, and the configuration of an API with Heroku. The tutorial emphasizes the flexibility and ease of using Ionic and Capacitor to build cross-platform applications, encouraging developers to explore further resources and tutorials provided by Ionic and Stream for enhancing their app development skills.

The fifth installment of a tutorial series on creating a full-stack application using Flask and Stream covers setting up a customizable user profile page, integrating content with Stream, and creating a testing module for application validation. The tutorial begins by creating a user.html template to display user information, utilizing Jinja for conditional rendering, and setting up routes to manage user data retrieval. It then guides users through adding a profile link to the navbar for easy navigation and updating the database with new fields using Alembic for migrations. The series emphasizes testing application functions through a newly created testing module, designed to ensure functionality and reliability. Additionally, it introduces the Stream-Python library for managing user activities and encourages experimentation with its features. The tutorial underscores the importance of testing and database management while preparing for more advanced functionalities such as user collections in the upcoming parts of the series.

With the advancement in secure healthcare communication technology, there are numerous HIPAA-compliant applications available that facilitate secure interactions with patients while safeguarding their Protected Health Information (PHI). These applications cater to various healthcare roles, from doctors and nurses to hospital managers, offering features like live chat, video chat, text messaging, and group messaging, without necessarily requiring app downloads. Notable apps include OhMD, Backline, MedChat, Luma Health, Health Engage, Well, Trillian, and Tiger Connect, each providing unique capabilities such as secure messaging, appointment scheduling, and automated patient communication. Additionally, platforms like Stream offer customizable solutions for building in-house HIPAA-compliant messaging services, ensuring data protection and compliance through encryption and legal agreements. These innovations aid in enhancing patient engagement, streamlining communication processes, and supporting remote healthcare delivery effectively.

Deploying applications can be simplified using Docker and Kubernetes, as demonstrated by creating a Node.js-based API and a React frontend for a chat application utilizing the Stream Chat API. The process involves setting up a Stream account for API keys, modifying a Node.js API, and configuring a .env file with necessary credentials. Docker is used to create an image of the application, which is then deployed to Kubernetes using configuration files in YAML format. Kubernetes manages the deployment and ensures compatibility across different environments. The React app is set up to interact with the API endpoint, enabling real-time chat functionality with minimal setup, thanks to Stream's robust API and documentation. The tutorial guides developers through installation steps, environment preparation, and deployment, emphasizing the ease of developing real-time applications using modern containerization and orchestration tools.

The text provides a comprehensive tutorial on building a chat application using Stream Chat, which allows businesses to retain and process chat transcripts to improve customer interactions. It emphasizes the importance of keeping records of conversations for decision-making and customer satisfaction. The guide outlines the steps to set up a chat interface for both customers and support agents using Node.js and React, and demonstrates how to send chat transcripts via email using Mailgun. Key components of the application include initializing the chat interface, managing user authentication, and implementing a transcript request button that facilitates the email dispatch of chat transcripts. The tutorial also covers server-side configurations necessary for integrating Mailgun's email service, ensuring that chat interactions can be effectively documented and shared with users upon request.

In the fourth installment of a tutorial series on building a full-stack application with Flask and Stream, the article focuses on setting up user authentication and permissions. It details the creation of views and forms for user registration, login, and logout, as well as functionalities for changing email or password. The process involves setting up an authentication folder, configuring Flask-Migrate for database changes, creating registration and login forms with custom validators, and integrating email confirmation using Flask-Mail. Additionally, the tutorial covers the navigation setup using a modular approach with Jinja, and implementing error handling for common HTTP errors. The article concludes with plans to develop user profile pages and testing strategies in the next installment.