Why You Should Become a DevRel in 2026: A Data-Driven Career Analysis

// DevRel GitHub Engagement Reporter v1.0.0
// Uses https://github.com/octokit/core.js v4.2.0 to aggregate repo metrics
// for quarterly DevRel impact reports
import { Octokit } from "octokit";
import { config } from "dotenv";

// Load environment variables from .env file
config();

// Validate required environment variables
if (!process.env.GITHUB_TOKEN) {
  console.error("ERROR: GITHUB_TOKEN environment variable is required");
  process.exit(1);
}
if (!process.env.TARGET_ORG) {
  console.error("ERROR: TARGET_ORG environment variable is required (e.g., 'facebook')");
  process.exit(1);
}

// Initialize Octokit with personal access token
const octokit = new Octokit({ auth: process.env.GITHUB_TOKEN });

/**
 * Fetches all public repositories for a given GitHub organization
 * @param {string} org - GitHub organization name
 * @returns {Array} List of repository objects
 */
async function fetchOrgRepos(org) {
  const repos = [];
  let page = 1;
  const perPage = 100;

  try {
    while (true) {
      const response = await octokit.rest.repos.listForOrg({
        org,
        type: "public",
        per_page: perPage,
        page,
      });

      // Check for rate limiting headers
      const rateLimitRemaining = response.headers["x-ratelimit-remaining"];
      const rateLimitReset = response.headers["x-ratelimit-reset"];
      if (rateLimitRemaining && parseInt(rateLimitRemaining) < 10) {
        console.warn(`WARN: Rate limit low (${rateLimitRemaining} remaining). Reset at ${new Date(rateLimitReset * 1000)}`);
      }

      if (response.data.length === 0) break;
      repos.push(...response.data);
      page++;
    }
    return repos;
  } catch (error) {
    console.error(`ERROR fetching repos for org ${org}:`, error.message);
    throw error;
  }
}

/**
 * Aggregates engagement metrics for a single repository
 * @param {Object} repo - GitHub repository object
 * @returns {Object} Aggregated metrics
 */
async function getRepoMetrics(repo) {
  try {
    // Fetch discussion count (requires Octokit v4.2.0+)
    const discussions = await octokit.rest.discussions.listForRepo({
      owner: repo.owner.login,
      repo: repo.name,
      per_page: 1,
    }).then(res => res.headers["x-total-count"] || 0).catch(() => 0);

    return {
      name: repo.name,
      stars: repo.stargazers_count,
      forks: repo.forks_count,
      open_issues: repo.open_issues_count,
      discussions: parseInt(discussions),
      url: repo.html_url,
    };
  } catch (error) {
    console.error(`ERROR fetching metrics for ${repo.name}:`, error.message);
    return null;
  }
}

// Main execution
async function main() {
  try {
    console.log(`Fetching repos for organization: ${process.env.TARGET_ORG}`);
    const repos = await fetchOrgRepos(process.env.TARGET_ORG);
    console.log(`Found ${repos.length} public repositories`);

    const metricsPromises = repos.map(repo => getRepoMetrics(repo));
    const allMetrics = (await Promise.all(metricsPromises)).filter(m => m !== null);

    // Calculate totals
    const totals = allMetrics.reduce((acc, curr) => {
      acc.total_stars += curr.stars;
      acc.total_forks += curr.forks;
      acc.total_issues += curr.open_issues;
      acc.total_discussions += curr.discussions;
      return acc;
    }, { total_stars: 0, total_forks: 0, total_issues: 0, total_discussions: 0 });

    console.log("\n=== Quarterly DevRel Engagement Report ===");
    console.log(`Organization: ${process.env.TARGET_ORG}`);
    console.log(`Repositories analyzed: ${allMetrics.length}`);
    console.log(`Total Stars: ${totals.total_stars.toLocaleString()}`);
    console.log(`Total Forks: ${totals.total_forks.toLocaleString()}`);
    console.log(`Total Open Issues: ${totals.total_issues.toLocaleString()}`);
    console.log(`Total Discussions: ${totals.total_discussions.toLocaleString()}`);
    console.log("=========================================\n");

    // Output top 5 repos by stars
    console.log("Top 5 Repos by Stars:");
    allMetrics.sort((a, b) => b.stars - a.stars).slice(0, 5).forEach((repo, idx) => {
      console.log(`${idx + 1}. ${repo.name}: ${repo.stars.toLocaleString()} stars | ${repo.discussions} discussions`);
    });
  } catch (error) {
    console.error("Fatal error in main execution:", error.message);
    process.exit(1);
  }
}

// Run the script
main();

# DevRel Community Sentiment Analyzer v0.2.1
# Analyzes GitHub issue comments and Discourse posts to measure developer sentiment
# Requires: transformers==4.36.0, requests==2.31.0, python-dotenv==1.0.0
import os
import requests
from dotenv import load_dotenv
from transformers import pipeline
from datetime import datetime, timedelta

# Load environment variables
load_dotenv()

# Validate required config
required_vars = ["GITHUB_TOKEN", "DISCOURSE_URL", "DISCOURSE_API_KEY"]
for var in required_vars:
    if not os.getenv(var):
        raise ValueError(f"Missing required environment variable: {var}")

# Initialize sentiment analysis pipeline (DistilBERT fine-tuned on SST-2)
try:
    sentiment_analyzer = pipeline(
        "sentiment-analysis",
        model="distilbert-base-uncased-finetuned-sst-2-english",
        truncation=True
    )
    print("Loaded sentiment analysis model successfully")
except Exception as e:
    print(f"ERROR loading sentiment model: {e}")
    exit(1)

# GitHub API base URL
GITHUB_API = "https://api.github.com"

def fetch_github_issue_comments(owner: str, repo: str, days_back: int = 30) -> list:
    """Fetch issue comments from a GitHub repo from the last N days"""
    headers = {"Authorization": f"token {os.getenv('GITHUB_TOKEN')}"}
    since_date = (datetime.now() - timedelta(days=days_back)).isoformat()
    comments = []
    page = 1

    try:
        while True:
            response = requests.get(
                f"{GITHUB_API}/repos/{owner}/{repo}/issues/comments",
                headers=headers,
                params={"since": since_date, "per_page": 100, "page": page}
            )
            response.raise_for_status()

            # Check rate limits
            remaining = response.headers.get("X-RateLimit-Remaining")
            if remaining and int(remaining) < 10:
                reset_time = datetime.fromtimestamp(int(response.headers["X-RateLimit-Reset"]))
                print(f"WARN: GitHub rate limit low ({remaining} remaining). Resets at {reset_time}")

            batch = response.json()
            if not batch:
                break
            comments.extend(batch)
            page += 1
        return comments
    except requests.exceptions.RequestException as e:
        print(f"ERROR fetching GitHub comments: {e}")
        return []

def fetch_discourse_posts(days_back: int = 30) -> list:
    """Fetch posts from a Discourse forum from the last N days"""
    discourse_url = os.getenv("DISCOURSE_URL")
    api_key = os.getenv("DISCOURSE_API_KEY")
    headers = {"Api-Key": api_key, "Api-Username": "system"}
    since_date = (datetime.now() - timedelta(days=days_back)).isoformat()
    posts = []
    page = 1

    try:
        while True:
            response = requests.get(
                f"{discourse_url}/posts.json",
                headers=headers,
                params={"before": since_date, "per_page": 50, "page": page}
            )
            response.raise_for_status()
            batch = response.json().get("latest_posts", [])
            if not batch:
                break
            posts.extend(batch)
            page += 1
        return posts
    except requests.exceptions.RequestException as e:
        print(f"ERROR fetching Discourse posts: {e}")
        return []

def analyze_sentiment(texts: list) -> dict:
    """Run sentiment analysis on a list of text strings"""
    if not texts:
        return {"positive": 0, "negative": 0, "neutral": 0, "total": 0}

    try:
        results = sentiment_analyzer(texts[:32])  # Batch size limit for model
        sentiment_counts = {"positive": 0, "negative": 0, "neutral": 0}

        for result in results:
            label = result["label"].lower()
            if label == "positive":
                sentiment_counts["positive"] += 1
            elif label == "negative":
                sentiment_counts["negative"] += 1
            else:
                sentiment_counts["neutral"] += 1

        return {
            **sentiment_counts,
            "total": len(texts),
            "positive_pct": (sentiment_counts["positive"] / len(texts)) * 100,
            "negative_pct": (sentiment_counts["negative"] / len(texts)) * 100
        }
    except Exception as e:
        print(f"ERROR during sentiment analysis: {e}")
        return {"positive": 0, "negative": 0, "neutral": 0, "total": 0}

def main():
    # Configuration
    owner = "octokit"
    repo = "core.js"
    days_back = 30

    print(f"Analyzing community sentiment for {owner}/{repo} over last {days_back} days...")

    # Fetch data
    github_comments = fetch_github_issue_comments(owner, repo, days_back)
    print(f"Fetched {len(github_comments)} GitHub issue comments")

    discourse_posts = fetch_discourse_posts(days_back)
    print(f"Fetched {len(discourse_posts)} Discourse posts")

    # Extract text content
    github_texts = [comment["body"] for comment in github_comments if comment.get("body")]
    discourse_texts = [post["raw"] for post in discourse_posts if post.get("raw")]
    all_texts = github_texts + discourse_texts

    # Analyze sentiment
    sentiment_results = analyze_sentiment(all_texts)

    # Output report
    print("\n=== DevRel Community Sentiment Report ===")
    print(f"Total Content Analyzed: {sentiment_results['total']}")
    print(f"GitHub Comments: {len(github_texts)}")
    print(f"Discourse Posts: {len(discourse_texts)}")
    print(f"Positive Sentiment: {sentiment_results['positive_pct']:.1f}% ({sentiment_results['positive']} items)")
    print(f"Negative Sentiment: {sentiment_results['negative_pct']:.1f}% ({sentiment_results['negative']} items)")
    print(f"Neutral Sentiment: {100 - sentiment_results['positive_pct'] - sentiment_results['negative_pct']:.1f}%")
    print("========================================\n")

    # Alert on high negative sentiment
    if sentiment_results['negative_pct'] > 25:
        print(f"ALERT: Negative sentiment ({sentiment_results['negative_pct']:.1f}%) exceeds 25% threshold. Investigate community pain points.")

if __name__ == "__main__":
    main()

// DevRel ROI Calculator v1.1.0
// Calculates return on investment for DevRel activities based on
// acquisition cost, conversion rates, and LTV of developer users
package main

import (
    "encoding/json"
    "fmt"
    "log"
    "os"
    "text/tabwriter"
    "time"
)

// Activity represents a single DevRel activity (e.g., conference talk, blog post)
type Activity struct {
    Name           string    `json:"name"`
    Type           string    `json:"type"` // "conference", "blog", "workshop", "webinar"
    Cost           float64   `json:"cost_usd"` // Total cost of activity (travel, production, etc.)
    Date           time.Time `json:"date"`
    Impressions    int       `json:"impressions"` // Estimated number of developers reached
    Conversions    int       `json:"conversions"` // Number of developers who signed up/converted
    AvgLTV         float64   `json:"avg_ltv_usd"` // Average lifetime value of a converted developer
}

// ROICalculation holds the results of ROI calculation for an activity
type ROICalculation struct {
    ActivityName    string  `json:"activity_name"`
    TotalCost       float64 `json:"total_cost_usd"`
    TotalRevenue    float64 `json:"total_revenue_usd"`
    ROI             float64 `json:"roi_pct"` // (Revenue - Cost) / Cost * 100
    ConversionRate  float64 `json:"conversion_rate_pct"`
    CostPerAcquisition float64 `json:"cpa_usd"` // Cost per acquired user
}

func loadActivities(filePath string) ([]Activity, error) {
    file, err := os.Open(filePath)
    if err != nil {
        return nil, fmt.Errorf("failed to open activities file: %w", err)
    }
    defer file.Close()

    var activities []Activity
    decoder := json.NewDecoder(file)
    if err := decoder.Decode(&activities); err != nil {
        return nil, fmt.Errorf("failed to decode activities JSON: %w", err)
    }

    // Validate activities
    for i, activity := range activities {
        if activity.Cost < 0 {
            return nil, fmt.Errorf("activity %d (%s) has negative cost", i, activity.Name)
        }
        if activity.Impressions < 0 {
            return nil, fmt.Errorf("activity %d (%s) has negative impressions", i, activity.Name)
        }
        if activity.Conversions < 0 {
            return nil, fmt.Errorf("activity %d (%s) has negative conversions", i, activity.Name)
        }
        if activity.Conversions > activity.Impressions {
            log.Printf("WARN: Activity %s has more conversions than impressions", activity.Name)
        }
    }

    return activities, nil
}

func calculateROI(activities []Activity) []ROICalculation {
    results := make([]ROICalculation, 0, len(activities))

    for _, activity := range activities {
        totalRevenue := float64(activity.Conversions) * activity.AvgLTV
        roi := 0.0
        if activity.Cost > 0 {
            roi = ((totalRevenue - activity.Cost) / activity.Cost) * 100
        }
        conversionRate := 0.0
        if activity.Impressions > 0 {
            conversionRate = (float64(activity.Conversions) / float64(activity.Impressions)) * 100
        }
        cpa := 0.0
        if activity.Conversions > 0 {
            cpa = activity.Cost / float64(activity.Conversions)
        }

        results = append(results, ROICalculation{
            ActivityName:       activity.Name,
            TotalCost:          activity.Cost,
            TotalRevenue:       totalRevenue,
            ROI:                roi,
            ConversionRate:     conversionRate,
            CostPerAcquisition: cpa,
        })
    }

    return results
}

func printResults(results []ROICalculation) {
    w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', tabwriter.Debug)
    fmt.Fprintln(w, "Activity\tCost (USD)\tRevenue (USD)\tROI (%)   Conversion Rate (%) CPA (USD)")
    fmt.Fprintln(w, "-------\t-------\t-------\t-------\t-------\t-------")

    totalCost := 0.0
    totalRevenue := 0.0
    for _, res := range results {
        fmt.Fprintf(w, "%s\t$%.2f\t$%.2f\t%.1f%%\t%.1f%%\t$%.2f\n",
            res.ActivityName,
            res.TotalCost,
            res.TotalRevenue,
            res.ROI,
            res.ConversionRate,
            res.CostPerAcquisition,
        )
        totalCost += res.TotalCost
        totalRevenue += res.TotalRevenue
    }

    fmt.Fprintln(w, "-------\t-------\t-------\t-------\t-------\t-------")
    totalROI := 0.0
    if totalCost > 0 {
        totalROI = ((totalRevenue - totalCost) / totalCost) * 100
    }
    fmt.Fprintf(w, "TOTAL\t$%.2f\t$%.2f\t%.1f%%\t-\t-\n", totalCost, totalRevenue, totalROI)
    w.Flush()
}

func main() {
    if len(os.Args) < 2 {
        log.Fatal("Usage: devrel-roi-calc ")
    }

    activities, err := loadActivities(os.Args[1])
    if err != nil {
        log.Fatalf("Failed to load activities: %v", err)
    }

    if len(activities) == 0 {
        log.Fatal("No activities found in input file")
    }

    fmt.Println("Calculating DevRel ROI...")
    results := calculateROI(activities)
    printResults(results)

    // Save results to JSON
    resultsFile, err := os.Create("roi-results.json")
    if err != nil {
        log.Printf("WARN: Failed to save results to file: %v", err)
        return
    }
    defer resultsFile.Close()

    encoder := json.NewEncoder(resultsFile)
    encoder.SetIndent("", "  ")
    if err := encoder.Encode(results); err != nil {
        log.Printf("WARN: Failed to encode results JSON: %v", err)
    }
    fmt.Println("\nResults saved to roi-results.json")
}

name: Validate PR
on: [pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: 20 }
      - run: npm ci
      - run: npm test
      - run: npm run lint

---
title: "Debugging Node.js Memory Leaks with Clinic.js"
date: 2026-01-15
tags: [nodejs, performance, debugging]
authors: [your-github-username]
benchmarks:
  - tool: clinic heapprof
    version: 4.2.0
    improvement: 68% memory reduction
---

// Track when a developer copies a code sample
document.querySelectorAll('.code-sample').forEach(block => {
  block.addEventListener('copy', (e) => {
    gtag('event', 'code_copy', {
      'code_language': block.dataset.lang,
      'post_slug': window.location.pathname,
      'value': 1
    });
  });
});