Pull vs. Push Architectures & Fan-Out Systems

interface Tweet {
  id: string;
  authorId: string;
  timestamp: number;
}

const CELEBRITY_THRESHOLD = 25_000;

export class HybridFeedService {
  async postTweet(authorId: string, tweet: Tweet, followerCount: number): Promise {
    await db.saveTweet(tweet);

    if (followerCount >= CELEBRITY_THRESHOLD) {
      // Lazy Pull: write only to celebrity list
      await redis.lpush(`celeb:${authorId}`, JSON.stringify(tweet));
    } else {
      // Eager Push: dispatch background fan-out job
      await queue.enqueue('fanout_job', { authorId, tweet });
    }
  }

  async getHomeFeed(userId: string, followedCelebs: string[], limit = 20): Promise {
    // 1. Fetch pre-computed standard user feed
    const rawInbox = await redis.lrange(`feed:${userId}`, 0, limit - 1);
    const standardTweets: Tweet[] = rawInbox.map(s => JSON.parse(s));

    // 2. Fetch followed celebrities
    const celebTweets: Tweet[] = [];
    for (const celebId of followedCelebs) {
      const raw = await redis.lrange(`celeb:${celebId}`, 0, limit - 1);
      celebTweets.push(...raw.map(s => JSON.parse(s)));
    }

    // 3. In-memory merge and sort
    return [...standardTweets, ...celebTweets]
      .sort((a, b) => b.timestamp - a.timestamp)
      .slice(0, limit);
  }
}
        

package main

import (
	"sort"
)

const CelebrityThreshold = 25000

type Tweet struct {
	ID        string `json:"id"`
	AuthorID  string `json:"author_id"`
	Timestamp int64  `json:"timestamp"`
}

type FeedService struct {
	redisClient RedisClient
}

func (s *FeedService) PostTweet(authorID string, tweet Tweet, followerCount int) {
	if followerCount >= CelebrityThreshold {
		// VIP: Write to celebrity timeline only
		s.redisClient.LPush("celeb:"+authorID, tweet)
	} else {
		// Normal: Async worker fan-out to followers
		go s.fanOutToFollowers(authorID, tweet)
	}
}

func (s *FeedService) GetFeed(userID string, followedCelebs []string, limit int) []Tweet {
	inbox := s.redisClient.LRange("feed:"+userID, 0, int64(limit-1))
	for _, celebID := range followedCelebs {
		celebTweets := s.redisClient.LRange("celeb:"+celebID, 0, int64(limit-1))
		inbox = append(inbox, celebTweets...)
	}

	sort.Slice(inbox, func(i, j int) bool {
		return inbox[i].Timestamp > inbox[j].Timestamp
	})

	if len(inbox) > limit {
		return inbox[:limit]
	}
	return inbox
}
        

import java.util.*;
import java.util.stream.Collectors;

public class HybridFeedService {
    private static final int CELEBRITY_THRESHOLD = 25_000;

    public record Tweet(String id, String authorId, long timestamp) {}

    public void postTweet(String authorId, Tweet tweet, int followerCount) {
        if (followerCount >= CELEBRITY_THRESHOLD) {
            // Lazy path: store in celebrity list
            redis.lpush("celeb:" + authorId, tweet);
        } else {
            // Eager path: queue fan-out
            taskQueue.enqueueFanout(authorId, tweet);
        }
    }

    public List<Tweet> getFeed(String userId, List<String> followedCelebs, int limit) {
        List<Tweet> feed = new ArrayList<>(redis.lrange("feed:" + userId, 0, limit - 1));

        for (String celebId : followedCelebs) {
            feed.addAll(redis.lrange("celeb:" + celebId, 0, limit - 1));
        }

        return feed.stream()
            .sorted(Comparator.comparingLong(Tweet::timestamp).reversed())
            .limit(limit)
            .collect(Collectors.toList());
    }
}
        

#include <string>
#include <vector>
#include <algorithm>

struct Tweet {
    std::string id;
    std::string author_id;
    int64_t timestamp;
};

const int CELEBRITY_THRESHOLD = 25000;

class HybridFeedService {
public:
    void post_tweet(const std::string& author_id, const Tweet& tweet, int follower_count) {
        if (follower_count >= CELEBRITY_THRESHOLD) {
            // VIP: Single Redis list insert
            redis_lpush("celeb:" + author_id, tweet);
        } else {
            // Eager fan-out to followers
            enqueue_fanout(author_id, tweet);
        }
    }

    std::vector<Tweet> get_feed(const std::string& user_id, const std::vector<std::string>& followed_celebs, size_t limit) {
        std::vector<Tweet> feed = redis_lrange("feed:" + user_id, 0, limit - 1);

        for (const auto& celeb_id : followed_celebs) {
            auto celeb_tweets = redis_lrange("celeb:" + celeb_id, 0, limit - 1);
            feed.insert(feed.end(), celeb_tweets.begin(), celeb_tweets.end());
        }

        std::sort(feed.begin(), feed.end(), [](const Tweet& a, const Tweet& b) {
            return a.timestamp > b.timestamp;
        });

        if (feed.size() > limit) feed.resize(limit);
        return feed;
    }
};