subscribe via RSS

categories: api, api-design, community, fanout, grip, mongrel2, protocols, pushpin, python, realtime, scalability, security, usability, walkthroughs, webhooks, websockets, xmpp, zeromq, zurl

  • Realtime data and continuous delivery

    Software development teams are beginning to realize the benefits of continuous, test-driven delivery of new releases.

    Instead of a single, milestone release (waterfall development) or multiple, internal test releases before major external ones (agile development), continuous delivery focuses on constant releasing of features to market throughout the development process.

    The goal of continuous delivery is that code is always ready to deploy and features are constantly rolled out independent of ‘releases’ – and doing so properly requires realtime data.

    (more...)
  • Building a realtime chat app with Django and Fanout Cloud

    Chat is one of the most popular uses of realtime data. In this article we’ll explain how to build a web chat app in Django, using Django EventStream and Fanout Cloud. The Django EventStream module makes it easy to push JSON events through Fanout Cloud to connected clients.

    djangochat

    (more...)
  • Reliable Server-Sent Events for Django

    Today we’re pleased to introduce Django EventStream, a module that provides Server-Sent Events capability to your Django server application. It relies on Pushpin or Fanout Cloud to manage the client connections. Events can optionally be persisted to your database, for highly reliable delivery.

    (more...)
  • Realtime data for smart notifications

    It’s becoming the new normal that messaging and collaboration apps and platforms are available across multiple devices.

    Business tools like Slack and JIRA offer feature-rich mobile apps, and users increasingly consume content from social networks like Facebook on their mobile devices instead of a desktop or laptop.

    This isn’t a surprise – and we’re here to share our perspective on how developers can use realtime data to provide cross-platform users with the best notification experience.

    (more...)
  • What is realtime?

    Many software developers are familiar with realtime, but we believe that realtime concepts and user experiences are becoming increasingly important for less technical individuals to understand.

    At Fanout, we power realtime APIs to instantly push data to endpoints – which can range from the actual endpoints of an API (the technical term) to external businesses or end users. We use the word in this post loosely to refer to any destination for data.

    We’re here to share our experience with realtime: we’ll provide a definition and current examples, peer into the future of realtime, and try and shed some light on the eternal realtime vs. real-time vs. real time semantic debate.

    (more...)
  • Pushpin reliable streaming

    Earlier this month we discussed the challenges of pushing data reliably. Fanout products such as Pushpin (and Fanout Cloud, which runs Pushpin) do not entirely insulate developers from these challenges, as it is not possible to do so within our scope. However, we recently devised a way to reduce the pain involved.

    Realtime APIs usually require receivers to juggle two data sources if they want to receive data reliably. For example, a client might listen for updates using a best-effort streaming API, and recover data using a REST API. So we thought, what if Pushpin could manage these two data sources, such that the client only needs to worry about one?

    (more...)
  • Push and reliability

    In push architectures, one of the main challenges is delivering data reliably to receivers. There are many reasons for this:

    • Most push architectures (including those developed by our company) use the publish-subscribe messaging pattern, which is unreliable.
    • TCP’s built-in reliability is not enough to ensure delivery, as modern network sessions span multiple connections.
    • Receivers can’t tell the difference between data loss and intentional silence.
    • There is no one size fits all answer.

    The last point trips up developers new to this problem space, who may wish for push systems to provide “guaranteed delivery.” If only it were that simple. Like many challenges in computer science, there isn’t a best answer, just trade-offs you are willing to accept.

    Below we’ll go over the various issues and recommended practices around reliable push.

    (more...)
  • Moving from polling to long-polling

    If you’ve built a REST API that clients poll for updates, you’ve probably considered adding a realtime push mechanism. Maybe you’ve been putting it off due to the added complexity, or the impact it might have on your API contract. These are valid concerns, but push doesn’t have to be that complicated.

    In this article we’ll discuss how to update an API to use long-polling. It assumes:

    1. You have an existing REST API.
    2. You have clients repeatedly polling this API.

    Long-polling is not the same as “plain” polling. With long-polling, the server delays the response to the client if there is no new data yet. This enables the server to respond instantly whenever the data does change. Aside from providing actual realtime updates, what’s great about long-polling is that technically it’s still RESTful, requiring hardly any changes to your API contract or client code.

    Of course, long-polling may not be as efficient as streaming mechanisms like Server-Sent Events or WebSockets, but it’s inarguably more efficient than plain-polling. Let’s compare:

    Mechanism Latency Load
    Plain-polling As high as the polling interval (e.g. 5 second interval means updates will be up to 5 seconds late) High
    Long-polling Zero Order of magnitude reduction


    Long-polling is a great way to dip your feet in the realtime waters without having to dramatically change your API contract and client code.

    (more...)
  • Five years of Fanout

    A note from our founder, Justin.

    Holy cow, it’s been five years. Five years ago today, Fanout was registered as a company. Back then, all we had were some scribbles in a text file. These days we have a production-ready product and many paying customers. I want to give a big thanks to our investors, advisors, mentors, early adopters, friends, and everyone else who helped get us here.

    I also want to take this moment to share some of our experiences over the years.

    (more...)
  • Serverless WebSocket chat

    Serverless development is a hot topic lately. Development & operations of a web service can be greatly simplified by writing your application logic as short-lived functions, and relying on outside organizations for the development of all the other components in your stack (e.g. databases, gateways, container engines, etc). The term “serverless” is a bit funny because of course there are still servers in your stack, and they may even be your own servers, but the main idea is you no longer have to worry about your own long-running application code.

    This all sounds great, but an issue arises: in this serverless world, how do you support long-lived connections (e.g. HTTP streaming/WebSocket connections) for realtime data push, without long-running application code? By delegating connection management to another component, of course! In this article we’ll talk about how to build a simple chat service with Pushpin, using Microcule for running the backend worker function.

    (more...)
X

Sign up for the Fanout Newsletter: