Stream

I work at Stream and I'm immensely proud of what our team is working on here at the company. Most recently, we announced our Android SDK accompanied by an extensive tutorial for Java and Kotlin. The tutorial covers just about everything you need to know when it comes to using our Android SDK for Stream Chat. The Android SDK touches many features offered by Stream Chat – more specifically, typing status, read state, file uploads, threads, reactions, editing messages, and commands. Head over to https://getstream.io/tutorials/android-chat/ and give it a whirl!

On occasion, I like to set out and write tutorials around the technology that I’m currently working with. With Stream’s recent release of its Python SDK for Chat, I felt compelled to write up a tutorial that would be engaging to developers interested in building a chat application with Python .

Most of the time, my tutorials are rather short and straight forward; however, with the Python tutorial, I wanted to take it a step further and throw in some additional technology to make things fun.

I chose to use a combination of our Python Chat SDK, the Stream React Chat components and Django for handling backend auth.

It was a lot of fun and I’m very proud to say that the tutorial turned out well. If you’re interested in reading, you can find the full Python Chat tutorial over on Dev.to.

Thank you and I hope you enjoy the tutorial on building an app with Python and Chat by Stream !

Recently, the team at Stream published a React Native SDK for our new Chat by Stream product. React Native brings the power of JavaScript to the world of mobile development, making it easy to develop apps for multiple platforms. We decided to publish two different endpoints for the SDK – Expo and React Native (non-expo), to avoid the hurdle and setup of using the Expo library in React Native only projects on the consumer side.

The capability of style customization is one a large deal breaker for frontend SDKs. To solve this, we decided to use styled-components in our SDK, which makes it easy to add support for themes on top of our existing components. This practice reduces the maintenance effort for stylings of custom components and keeps the overall codebase clean.

For module bundling, we decided to go with Rollup.js instead of Webpack due to its simplicity and performance in the area of library/module providers. We are using Babel for transpiling code, enabling our team to use JavaScript's next-generation features. Additionally, we are using the React Styleguidist component documentation, which makes documenting the React Native code a breeze.

I had a pretty good time writing a React Native Chat tutorial. I used some great tools, some of which you likely know and others that you probably are not aware of. Here's my decision:

• @Stream Chat
• Expo
• Serverless
• Gifted Chat

The full tutorial can be found here: https://medium.com/@nparsons08/react-native-chat-with-chuck-norris-dd5721523742

Here at Stream, we recently build a powerful CLI to support our Feeds & Chat products. In doing so, we learned a lot about best practices when crafting a positive developer experience in the command line. Quick findings:

• JavaScript is more powerful than you think. Tap into the massive ecosystem and a large number of open-source projects.

• For inspiration, look at the functionality that Zeit and Heroku provide within their CLI to make for an awesome developer command line “experience”.

• If your API/CLI requires data persistence, store that data in a cache directory that is specific to your CLI. Load this using a util file as we do at Stream. Also, note that the fs-extra package will come in handy for this type of thing (even though support is built into Oclif).

• Oclif is the way to go, especially if you’re building a large CLI, as opposed to a single-command CLI. If you’re building a single-command CLI you can still use Oclif, just make sure to specify that it’s a single-command API when you’re scaffolding your CLI.

• Don’t want to use a framework? That’s okay! The package minimist provides argument parsing in the command line and can easily be used within your project.

• Use prompts, when you can, with enquirer or another package of your choosing. Users should be walked through the requirements of the command and asked for the data the command needs in order to execute properly. Note that this should never be required (e.g. let the user bypass the prompt if they pass the correct arguments).

• Use colors when possible to make your CLI a little easier on the eye. Chalk serves as a great tool for this. If you have response data that is well enough structured, don’t just print it out to the user (unless that’s what they specify). Instead, drop it in a table using

• Always allow the user to specify the output type (e.g. JSON), but default to a message that is human-readable.

• Keep it fast! For time-consuming tasks such as file uploads or commands that require multiple API calls, we recommend showing a loading indicator to let the user know that work is being done in the background. If you’re looking for a package on npm, we recommend checking out ora.

The full blog post can be found here: https://medium.com/@nparsons08/crafting-a-command-line-experience-that-developers-love-68657b20c28d

We stopping using Intercom and now use HubSpot support features because its more integrated with the CRM

VictorOps is a recent addition to our support stack. The best part about VictorOps is how they use a timeline to collaborate amongst team members. VictorOps is an elegant way to keep our team in the loop about outages. It also integrates well with Slack. This setup enables us to quickly react to any problems that make it into production, work together and resolve them faster. #Collaboration #MonitoringAggregation #Monitoring #GroupChatNotifications

Releasing new versions of our services is done by Travis CI. Travis first runs our test suite. Once it passes, it publishes a new release binary to GitHub.

Common tasks such as installing dependencies for the Go project, or building a binary are automated using plain old Makefiles. (We know, crazy old school, right?) Our binaries are compressed using UPX.

Travis has come a long way over the past years. I used to prefer Jenkins in some cases since it was easier to debug broken builds. With the addition of the aptly named “debug build” button, Travis is now the clear winner. It’s easy to use and free for open source, with no need to maintain anything.

#ContinuousIntegration #CodeCollaborationVersionControl

We heavily use AWS CloudFormation. Every single piece of our stack is defined in a CloudFormation template. Because our infrastructure is defined in code it has become trivial to launch new regions. If needed we are able to spawn a new dedicated shard in a few minutes. In addition, AWS Parameter Store is used to hold application settings. Our largest deployment is in US-East, but we also have regions in Tokyo, Singapore and Dublin.

#InfrastructureBuildTools #BuildTestDeploy

Our real time infrastructure is based on Go , Redis and the excellent gorilla websocket library. It implements the Bayeux protocol.

In terms of architecture it’s very similar to the node based Faye library. It was interesting to read the “Ditching Go for Node.js” post on Hacker News. The author moves from Go to Node to improve performance. We actually did the exact opposite and moved from Node to Go for our real time system. The new Go-based infrastructure handles 8x the traffic per node. #InMemoryDatabases #RealtimeBackendApi #ApplicationHosting #Languages #DataStores