Design Decisions

# Traditional approach: hundreds of hand-crafted features
features = {
    'post_age_hours': calculate_age(post),
    'author_follower_count': get_follower_count(author),
    'user_author_interaction_count': count_interactions(user, author),
    'post_reply_count': get_reply_count(post),
    'post_like_count': get_like_count(post),
    'text_length': len(post.text),
    'has_media': post.media is not None,
    'is_verified_author': author.verified,
    # ... hundreds more ...
}

# Phoenix approach: learn from behavior patterns
input = {
    'user': user_id,
    'history': [
        (post_1, author_1, 'like'),
        (post_2, author_2, 'reply'),
        (post_3, author_3, 'repost'),
        # User's engagement sequence
    ],
    'candidates': [post_A, post_B, post_C],
}

# Transformer discovers patterns automatically
scores = transformer(input)

# Traditional approach
user_embeddings = nn.Embedding(
    num_users=1_000_000_000,     # 1B users
    embedding_dim=256
)
# Memory: 1B × 256 × 4 bytes = 1 TB

post_embeddings = nn.Embedding(
    num_posts=10_000_000_000,    # 10B posts
    embedding_dim=256
)
# Memory: 10B × 256 × 4 bytes = 10 TB

# Total: 11+ TB just for embeddings

# Fixed memory regardless of vocabulary size
embedding_table = nn.Embedding(
    num_buckets=10_000_000,      # 10M buckets
    embedding_dim=256
)
# Memory: 10M × 256 × 4 bytes = 10 GB (1000× reduction)

# What does a single score mean?
relevance_score = 0.73  # High score, but...

# Possible interpretations:
# - User will click but not engage?
# - User will like but might block author later?
# - High engagement but low quality (clickbait)?
# - Informative but not entertaining?

# Cannot distinguish these scenarios!

predictions = {
    'P(like)': 0.35,           # Likely to like
    'P(reply)': 0.05,          # Unlikely to reply
    'P(repost)': 0.02,         # Unlikely to repost
    'P(click)': 0.60,          # Likely to click
    'P(dwell_long)': 0.40,     # Moderate dwell time
    'P(follow_author)': 0.03,  # Unlikely to follow
    'P(block)': 0.001,         # Very unlikely to block
    'P(report)': 0.0001,       # Extremely unlikely to report
}

# Clear interpretation: passive engagement, low deep engagement

# Monolithic approach: everything in one place
def get_recommendations(user_id):
    # Fetching
    in_network = fetch_in_network(user_id)
    out_network = fetch_out_network(user_id)
    
    # Hydration
    candidates = hydrate_metadata(in_network + out_network)
    
    # Filtering
    candidates = remove_duplicates(candidates)
    candidates = remove_blocked_authors(candidates, user_id)
    candidates = remove_muted_keywords(candidates, user_id)
    
    # Scoring
    for candidate in candidates:
        candidate.score = ml_model.score(user_id, candidate)
    
    # Selection
    return sorted(candidates, key=lambda c: c.score, reverse=True)[:100]

# Issues:
# - Hard to test individual stages
# - Difficult to add new stages
# - No parallelization of independent stages
# - Tight coupling between stages

// Each stage is a composable trait
pub trait Source {
    fn fetch_candidates(&self, query: &Query) -> Vec<Candidate>;
}

pub trait Hydrator {
    fn hydrate(&self, candidates: &mut [Candidate]);
}

pub trait Filter {
    fn filter(&self, candidates: Vec<Candidate>) -> Vec<Candidate>;
}

pub trait Scorer {
    fn score(&self, candidates: &mut [Candidate]);
}

// Compose into pipeline
let pipeline = CandidatePipeline::builder()
    .add_source(ThunderSource::new())           // In-network
    .add_source(PhoenixRetrievalSource::new())  // Out-of-network
    .add_hydrator(CoreDataHydrator::new())
    .add_filter(DeduplicateFilter::new())
    .add_filter(BlockedAuthorsFilter::new())
    .add_scorer(PhoenixRankingScorer::new())
    .add_scorer(AuthorDiversityScorer::new())
    .build();