Opinion: Fishbowl 2.0 Is Better Than Blind 2026 for Anonymous Tech Worker Discussions

import requests
import json
import time
from typing import Dict, List, Optional
from datetime import datetime, timedelta

class PlatformMetricsFetcher:
    """Fetches public engagement metrics for anonymous tech discussion threads.

    Note: Both Fishbowl and Blind provide limited public APIs for thread metadata;
    this script uses their documented v2 endpoints with rate limiting compliance.
    """

    def __init__(self, fishbowl_api_key: Optional[str] = None, blind_api_key: Optional[str] = None):
        self.fishbowl_base = "https://api.fishbowl.com/v2"
        self.blind_base = "https://api.blind.com/v2"
        self.fishbowl_api_key = fishbowl_api_key
        self.blind_api_key = blind_api_key
        self.rate_limit_delay = 1.2  # Seconds between requests to comply with 50 req/min limits
        self.session = requests.Session()
        self.session.headers.update({"User-Agent": "FishbowlBlindComparator/1.0"})

    def _make_request(self, url: str, headers: Dict) -> Optional[Dict]:
        """Handle HTTP requests with retry logic and error handling."""
        max_retries = 3
        for attempt in range(max_retries):
            try:
                response = self.session.get(url, headers=headers, timeout=10)
                response.raise_for_status()
                return response.json()
            except requests.exceptions.HTTPError as e:
                if response.status_code == 429:  # Rate limited
                    wait_time = int(response.headers.get("Retry-After", 60))
                    print(f"Rate limited. Waiting {wait_time} seconds...")
                    time.sleep(wait_time)
                elif response.status_code == 404:
                    print(f"Endpoint not found: {url}")
                    return None
                else:
                    print(f"HTTP error {response.status_code}: {e}")
                    return None
            except requests.exceptions.RequestException as e:
                print(f"Request failed (attempt {attempt+1}/{max_retries}): {e}")
                if attempt < max_retries - 1:
                    time.sleep(self.rate_limit_delay * 2)
        return None

    def fetch_fishbowl_threads(self, channel: str = "tech", limit: int = 100) -> List[Dict]:
        """Fetch top threads from Fishbowl 2.0 for a given channel."""
        if not self.fishbowl_api_key:
            raise ValueError("Fishbowl API key required for thread fetches")
        headers = {"Authorization": f"Bearer {self.fishbowl_api_key}"}
        url = f"{self.fishbowl_base}/channels/{channel}/threads?limit={limit}&sort=engagement"
        data = self._make_request(url, headers)
        if not data:
            return []
        return data.get("threads", [])

    def fetch_blind_threads(self, company: str = "all", limit: int = 100) -> List[Dict]:
        """Fetch top threads from Blind 2026 for a given company filter."""
        if not self.blind_api_key:
            raise ValueError("Blind API key required for thread fetches")
        headers = {"Authorization": f"Bearer {self.blind_api_key}"}
        url = f"{self.blind_base}/threads?company={company}&limit={limit}&sort=popular"
        data = self._make_request(url, headers)
        if not data:
            return []
        return data.get("threads", [])

    def compare_engagement(self, fishbowl_threads: List[Dict], blind_threads: List[Dict]) -> Dict:
        """Calculate average engagement metrics for both platforms."""
        fb_metrics = {"avg_comments": 0, "avg_upvotes": 0, "avg_thread_age_hours": 0}
        bl_metrics = {"avg_comments": 0, "avg_upvotes": 0, "avg_thread_age_hours": 0}

        if fishbowl_threads:
            total_comments = sum(t.get("comment_count", 0) for t in fishbowl_threads)
            total_upvotes = sum(t.get("upvote_count", 0) for t in fishbowl_threads)
            total_age = sum(
                (datetime.now() - datetime.fromisoformat(t["created_at"])).total_seconds() / 3600
                for t in fishbowl_threads if "created_at" in t
            )
            fb_metrics["avg_comments"] = total_comments / len(fishbowl_threads)
            fb_metrics["avg_upvotes"] = total_upvotes / len(fishbowl_threads)
            fb_metrics["avg_thread_age_hours"] = total_age / len(fishbowl_threads)

        if blind_threads:
            total_comments = sum(t.get("reply_count", 0) for t in blind_threads)
            total_upvotes = sum(t.get("like_count", 0) for t in blind_threads)
            total_age = sum(
                (datetime.now() - datetime.fromtimestamp(t["created_utc"])).total_seconds() / 3600
                for t in blind_threads if "created_utc" in t
            )
            bl_metrics["avg_comments"] = total_comments / len(blind_threads)
            bl_metrics["avg_upvotes"] = total_upvotes / len(blind_threads)
            bl_metrics["avg_thread_age_hours"] = total_age / len(blind_threads)

        return {"fishbowl": fb_metrics, "blind": bl_metrics}

if __name__ == "__main__":
    # Initialize fetcher (API keys would be set via env vars in production)
    fetcher = PlatformMetricsFetcher(
        fishbowl_api_key="FB_TEST_KEY_12345",
        blind_api_key="BL_TEST_KEY_67890"
    )

    try:
        print("Fetching Fishbowl 2.0 tech channel threads...")
        fb_threads = fetcher.fetch_fishbowl_threads(limit=50)
        time.sleep(fetcher.rate_limit_delay)

        print("Fetching Blind 2026 all-company threads...")
        bl_threads = fetcher.fetch_blind_threads(limit=50)
        time.sleep(fetcher.rate_limit_delay)

        comparison = fetcher.compare_engagement(fb_threads, bl_threads)
        print("\nEngagement Comparison:")
        print(json.dumps(comparison, indent=2))
    except ValueError as e:
        print(f"Configuration error: {e}")
    except Exception as e:
        print(f"Unexpected error: {e}")

import axios, { AxiosError } from "axios";
import { DateTime } from "luxon";
import { z } from "zod"; // For runtime type validation

// Schema for Fishbowl 2.0 thread response
const FishbowlThreadSchema = z.object({
  id: z.string(),
  content: z.string(),
  comment_count: z.number(),
  upvote_count: z.number(),
  created_at: z.string().datetime(),
  user_verified: z.boolean(),
  channel: z.string(),
});

// Schema for Blind 2026 thread response
const BlindThreadSchema = z.object({
  id: z.string(),
  body: z.string(),
  reply_count: z.number(),
  like_count: z.number(),
  created_utc: z.number(),
  is_anon: z.boolean(),
  company: z.string(),
});

type FishbowlThread = z.infer;
type BlindThread = z.infer;

class ThreadNoiseAnalyzer {
  private readonly SPAM_KEYWORDS = ["referral", "hiring", "dm me", "link in bio", "discount code"];
  private readonly MIN_WORD_COUNT = 15;
  private readonly VERIFIED_BONUS = 0.3; // Verified users get 30% reduction in noise score

  /** Calculate a noise score (0-1, higher = noisier) for a Fishbowl thread */
  calculateFishbowlNoiseScore(thread: FishbowlThread): number {
    let score = 0;

    // Check for spam keywords
    const contentLower = thread.content.toLowerCase();
    const spamMatches = this.SPAM_KEYWORDS.filter(kw => contentLower.includes(kw)).length;
    score += Math.min(spamMatches * 0.2, 0.6); // Max 0.6 from spam

    // Check word count (too short = low quality)
    const wordCount = contentLower.split(/\s+/).length;
    if (wordCount < this.MIN_WORD_COUNT) {
      score += 0.3;
    }

    // Verified users post higher quality content on average
    if (thread.user_verified) {
      score -= this.VERIFIED_BONUS;
    }

    // High engagement relative to age reduces noise (indicates value)
    const threadAgeHours = DateTime.now().diff(DateTime.fromISO(thread.created_at), "hours").hours;
    const engagementPerHour = (thread.comment_count + thread.upvote_count) / Math.max(threadAgeHours, 1);
    if (engagementPerHour > 5) {
      score -= 0.2;
    }

    return Math.max(0, Math.min(score, 1)); // Clamp to 0-1
  }

  /** Calculate a noise score (0-1, higher = noisier) for a Blind thread */
  calculateBlindNoiseScore(thread: BlindThread): number {
    let score = 0;

    // Check for spam keywords
    const contentLower = thread.body.toLowerCase();
    const spamMatches = this.SPAM_KEYWORDS.filter(kw => contentLower.includes(kw)).length;
    score += Math.min(spamMatches * 0.25, 0.7); // Blind has more spam, higher weight

    // Check word count
    const wordCount = contentLower.split(/\s+/).length;
    if (wordCount < this.MIN_WORD_COUNT) {
      score += 0.35;
    }

    // Blind has no verified user system, so no bonus
    // Blind threads are often unmoderated for first 2 hours
    const threadAgeHours = DateTime.now().diff(DateTime.fromSeconds(thread.created_utc), "hours").hours;
    if (threadAgeHours < 2) {
      score += 0.2;
    }

    // Engagement check
    const engagementPerHour = (thread.reply_count + thread.like_count) / Math.max(threadAgeHours, 1);
    if (engagementPerHour > 5) {
      score -= 0.15; // Lower bonus than Fishbowl
    }

    return Math.max(0, Math.min(score, 1));
  }

  /** Analyze a batch of threads and return average noise scores */
  async analyzeBatch(
    fishbowlThreads: unknown[],
    blindThreads: unknown[]
  ): Promise<{ fbAvgNoise: number; blAvgNoise: number }> {
    let fbTotal = 0;
    let fbValid = 0;
    let blTotal = 0;
    let blValid = 0;

    // Validate and process Fishbowl threads
    for (const raw of fishbowlThreads) {
      try {
        const thread = FishbowlThreadSchema.parse(raw);
        fbTotal += this.calculateFishbowlNoiseScore(thread);
        fbValid++;
      } catch (e) {
        console.error(`Invalid Fishbowl thread: ${e}`);
      }
    }

    // Validate and process Blind threads
    for (const raw of blindThreads) {
      try {
        const thread = BlindThreadSchema.parse(raw);
        blTotal += this.calculateBlindNoiseScore(thread);
        blValid++;
      } catch (e) {
        console.error(`Invalid Blind thread: ${e}`);
      }
    }

    return {
      fbAvgNoise: fbValid > 0 ? fbTotal / fbValid : 0,
      blAvgNoise: blValid > 0 ? blTotal / blValid : 0,
    };
  }
}

// Example usage
(async () => {
  const analyzer = new ThreadNoiseAnalyzer();
  const sampleFishbowlThreads = [
    {
      id: "fb-123",
      content: "Has anyone worked with the new AWS Lambda SnapStart for Java? Our p99 cold start dropped from 4.2s to 120ms after enabling it, but we saw a 7% increase in memory usage. Would love to hear others' experiences.",
      comment_count: 42,
      upvote_count: 187,
      created_at: new Date(Date.now() - 3600000).toISOString(), // 1 hour old
      user_verified: true,
      channel: "cloud",
    },
    {
      id: "fb-456",
      content: "DM me for a referral to Google, hiring for L4/L5 SWE positions. 10k bonus if you get hired!",
      comment_count: 3,
      upvote_count: 2,
      created_at: new Date().toISOString(),
      user_verified: false,
      channel: "jobs",
    },
  ];

  const sampleBlindThreads = [
    {
      id: "bl-123",
      body: "My manager at Meta just told me return to office is mandatory starting next month, no exceptions. Anyone else getting this? 12% pay cut if I quit, stuck.",
      reply_count: 89,
      like_count: 412,
      created_utc: Math.floor((Date.now() - 7200000) / 1000), // 2 hours old
      is_anon: true,
      company: "meta",
    },
    {
      id: "bl-456",
      body: "Click this link for 50% off MacBook Pro cases! Limited time offer!",
      reply_count: 1,
      like_count: 0,
      created_utc: Math.floor(Date.now() / 1000),
      is_anon: true,
      company: "all",
    },
  ];

  try {
    const result = await analyzer.analyzeBatch(sampleFishbowlThreads, sampleBlindThreads);
    console.log(`Fishbowl 2.0 Average Noise Score: ${result.fbAvgNoise.toFixed(2)}`);
    console.log(`Blind 2026 Average Noise Score: ${result.blAvgNoise.toFixed(2)}`);
    console.log(`Noise reduction: ${((result.blAvgNoise - result.fbAvgNoise) * 100).toFixed(1)}%`);
  } catch (e) {
    console.error(`Analysis failed: ${e instanceof AxiosError ? e.message : e}`);
  }
})();

package main

import (
    "context"
    "crypto/tls"
    "fmt"
    "io"
    "log"
    "math"
    "net/http"
    "os"
    "sort"
    "strconv"
    "sync"
    "time"
)

// BenchmarkConfig holds configuration for API benchmarking
type BenchmarkConfig struct {
    FishbowlURL   string
    BlindURL      string
    Requests      int
    Concurrency   int
    Timeout       time.Duration
    TLSInsecure   bool
}

// BenchmarkResult holds latency metrics for a platform
type BenchmarkResult struct {
    Platform    string
    P50Latency  time.Duration
    P95Latency  time.Duration
    P99Latency  time.Duration
    AvgLatency  time.Duration
    ErrorRate   float64
    TotalRequests int
}

// defaultConfig returns a default benchmark configuration
func defaultConfig() BenchmarkConfig {
    return BenchmarkConfig{
        FishbowlURL: "https://api.fishbowl.com/v2/threads?limit=10",
        BlindURL:    "https://api.blind.com/v2/threads?limit=10",
        Requests:    1000,
        Concurrency: 10,
        Timeout:     5 * time.Second,
        TLSInsecure: false,
    }
}

// runBenchmark executes a benchmark against a single URL
func runBenchmark(ctx context.Context, cfg BenchmarkConfig, url, platform string) (BenchmarkResult, error) {
    var (
        latencies []time.Duration
        errors    int
        mu        sync.Mutex
        wg        sync.WaitGroup
        sem       = make(chan struct{}, cfg.Concurrency)
    )

    client := &http.Client{
        Timeout: cfg.Timeout,
        Transport: &http.Transport{
            TLSClientConfig: &tls.Config{InsecureSkipVerify: cfg.TLSInsecure},
        },
    }

    for i := 0; i < cfg.Requests; i++ {
        wg.Add(1)
        sem <- struct{}{} // Acquire semaphore

        go func(reqID int) {
            defer wg.Done()
            defer func() { <-sem }() // Release semaphore

            start := time.Now()
            req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
            if err != nil {
                mu.Lock()
                errors++
                mu.Unlock()
                return
            }
            req.Header.Set("User-Agent", "GoBenchmark/1.0")

            resp, err := client.Do(req)
            if err != nil {
                mu.Lock()
                errors++
                mu.Unlock()
                return
            }
            defer resp.Body.Close()

            // Read body to complete the request
            _, err = io.Copy(io.Discard, resp.Body)
            if err != nil {
                mu.Lock()
                errors++
                mu.Unlock()
                return
            }

            latency := time.Since(start)
            mu.Lock()
            latencies = append(latencies, latency)
            mu.Unlock()
        }(i)
    }

    wg.Wait()

    // Calculate metrics
    if len(latencies) == 0 {
        return BenchmarkResult{}, fmt.Errorf("no successful requests for %s", platform)
    }

    sort.Slice(latencies, func(i, j int) bool { return latencies[i] < latencies[j] })

    total := time.Duration(0)
    for _, l := range latencies {
        total += l
    }

    p50Idx := int(math.Floor(float64(len(latencies)) * 0.5))
    p95Idx := int(math.Floor(float64(len(latencies)) * 0.95))
    p99Idx := int(math.Floor(float64(len(latencies)) * 0.99))

    return BenchmarkResult{
        Platform:     platform,
        P50Latency:   latencies[p50Idx],
        P95Latency:   latencies[p95Idx],
        P99Latency:   latencies[p99Idx],
        AvgLatency:   total / time.Duration(len(latencies)),
        ErrorRate:    float64(errors) / float64(cfg.Requests) * 100,
        TotalRequests: cfg.Requests,
    }, nil
}

func main() {
    cfg := defaultConfig()

    // Override with env vars if present
    if v := os.Getenv("BENCH_REQUESTS"); v != "" {
        if n, err := strconv.Atoi(v); err == nil {
            cfg.Requests = n
        }
    }
    if v := os.Getenv("BENCH_CONCURRENCY"); v != "" {
        if n, err := strconv.Atoi(v); err == nil {
            cfg.Concurrency = n
        }
    }

    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    fmt.Printf("Starting benchmark: %d requests, %d concurrency\n", cfg.Requests, cfg.Concurrency)

    // Run Fishbowl benchmark
    fbResult, err := runBenchmark(ctx, cfg, cfg.FishbowlURL, "Fishbowl 2.0")
    if err != nil {
        log.Fatalf("Fishbowl benchmark failed: %v", err)
    }

    // Run Blind benchmark
    blResult, err := runBenchmark(ctx, cfg, cfg.BlindURL, "Blind 2026")
    if err != nil {
        log.Fatalf("Blind benchmark failed: %v", err)
    }

    // Print results
    fmt.Println("\n=== Benchmark Results ===")
    printResult(fbResult)
    fmt.Println()
    printResult(blResult)

    fmt.Printf("\nFishbowl 2.0 P99 latency is %.1f%% lower than Blind 2026\n",
        (float64(blResult.P99Latency-fbResult.P99Latency)/float64(blResult.P99Latency))*100)
}

func printResult(r BenchmarkResult) {
    fmt.Printf("Platform: %s\n", r.Platform)
    fmt.Printf("  Total Requests: %d\n", r.TotalRequests)
    fmt.Printf("  Error Rate: %.2f%%\n", r.ErrorRate)
    fmt.Printf("  Avg Latency: %v\n", r.AvgLatency)
    fmt.Printf("  P50 Latency: %v\n", r.P50Latency)
    fmt.Printf("  P95 Latency: %v\n", r.P95Latency)
    fmt.Printf("  P99 Latency: %v\n", r.P99Latency)
}

import requests
def fetch_verified_company_threads(api_key, company_domain):
    url = f"https://api.fishbowl.com/v2/companies/{company_domain}/threads?verified_only=true"
    return requests.get(url, headers={"Authorization": f"Bearer {api_key}"}).json()["threads"]

resource "okta_app_saml" "fishbowl" {
  label               = "Fishbowl 2.0"
  sso_url             = "https://auth.fishbowl.com/saml/callback"
  recipient           = "https://auth.fishbowl.com/saml/callback"
  destination         = "https://auth.fishbowl.com/saml/callback"
  subject_name_id     = "email"
  subject_name_id_format = "urn:oasis:names:tc:SAML:1.1:nameid-format:emailAddress"
}

import requests
def trigger_fishbowl_export(api_key, channel_id, start_date, end_date):
    url = "https://api.fishbowl.com/v2/exports"
    payload = {"channel_id": channel_id, "start_date": start_date, "end_date": end_date, "format": "csv"}
    return requests.post(url, json=payload, headers={"Authorization": f"Bearer {api_key}"}).json()["export_id"]