Avoid guide resume building open-source: A Step-by-Step Guide

// Package main scans GitHub user repositories for resume-driven open source (RDOS) markers
// RDOS projects are defined as:
// 1. Repository description contains keywords: "resume", "todo app", "clone", "sample"
// 2. Fewer than 5 commits total
// 3. Zero open issues or pull requests
// 4. No updates in the last 90 days
package main

import (
    "context"
    "fmt"
    "log"
    "os"
    "strings"
    "time"

    "github.com/google/go-github/v60/github"
    "golang.org/x/oauth2"
)

// rdosKeywords are terms commonly found in resume-driven project descriptions
var rdosKeywords = []string{"resume", "todo app", "clone of", "sample project", "tutorial"}

// repoAgeThreshold is the maximum age of the last update to avoid being marked RDOS
const repoAgeThreshold = 90 * 24 * time.Hour

func main() {
    // Check for required GitHub token environment variable
    token := os.Getenv("GITHUB_TOKEN")
    if token == "" {
        log.Fatal("GITHUB_TOKEN environment variable is required")
    }

    // Authenticate with GitHub API using OAuth2
    ctx := context.Background()
    ts := oauth2.StaticTokenSource(&oauth2.Token{AccessToken: token})
    tc := oauth2.NewClient(ctx, ts)
    client := github.NewClient(tc)

    // Get target username from command line arguments
    if len(os.Args) < 2 {
        log.Fatal("Usage: rdos-scanner ")
    }
    username := os.Args[1]

    // Fetch all repositories for the target user (handle pagination)
    opt := &github.RepositoryListOptions{
        ListOptions: github.ListOptions{PerPage: 100},
    }
    var allRepos []*github.Repository
    for {
        repos, resp, err := client.Repositories.List(ctx, username, opt)
        if err != nil {
            log.Fatalf("Failed to list repositories for %s: %v", username, err)
        }
        allRepos = append(allRepos, repos...)
        if resp.NextPage == 0 {
            break
        }
        opt.Page = resp.NextPage
    }

    fmt.Printf("Scanning %d repositories for user %s...\n", len(allRepos), username)
    rdosCount := 0

    // Evaluate each repository for RDOS markers
    for _, repo := range allRepos {
        isRDOS := false
        repoName := repo.GetName()
        repoDesc := strings.ToLower(repo.GetDescription())

        // Check 1: Description contains RDOS keywords
        for _, kw := range rdosKeywords {
            if strings.Contains(repoDesc, kw) {
                isRDOS = true
                fmt.Printf("  [RDOS] %s: Description contains keyword '%s'\n", repoName, kw)
                break
            }
        }

        // Check 2: Last update older than threshold
        if repo.GetUpdatedAt().Before(time.Now().Add(-repoAgeThreshold)) {
            isRDOS = true
            fmt.Printf("  [RDOS] %s: No updates in %d days\n", repoName, repoAgeThreshold/24)
        }

        // Check 3: Fewer than 5 commits (requires separate API call)
        commits, _, err := client.Repositories.ListCommits(ctx, username, repoName, &github.CommitsListOptions{ListOptions: github.ListOptions{PerPage: 5}})
        if err != nil {
            log.Printf("Warning: Failed to fetch commits for %s: %v", repoName, err)
        } else if len(commits) < 5 {
            isRDOS = true
            fmt.Printf("  [RDOS] %s: Only %d commits\n", repoName, len(commits))
        }

        if isRDOS {
            rdosCount++
            fmt.Printf("⚠️  %s is likely resume-driven open source\n", repoName)
        } else {
            fmt.Printf("✅ %s appears to be meaningful OSS\n", repoName)
        }
    }

    fmt.Printf("\nScan complete. %d/%d repositories flagged as RDOS (%.1f%%)\n", rdosCount, len(allRepos), float64(rdosCount)/float64(len(allRepos))*100)
}

"""
Stack Overflow Problem Analyzer: Identifies underserved technical problems
to guide meaningful open-source project selection.
Underserved problems are defined as:
1. Tag has >1000 questions/month
2. Average score per question < 2 (indicates unclear/poor questions)
3. Answer rate < 60% (most questions go unanswered)
4. No highly upvoted (>50 score) answers for top 100 questions
"""

import os
import time
import logging
from datetime import datetime, timedelta
from typing import Dict, List, Tuple

import pandas as pd
from stackapi import StackAPI
from dotenv import load_dotenv

# Configure logging for debug output
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)

# Load environment variables for Stack Overflow API key (optional but recommended)
load_dotenv()
SO_KEY = os.getenv("STACKOVERFLOW_KEY", "")

# Initialize Stack API client with rate limiting
SITE = StackAPI("stackoverflow", key=SO_KEY)
SITE.page_size = 100
SITE.max_pages = 10  # Limit to 10 pages per request to avoid rate limits
SITE.wait_on_rate_limit = True
SITE.rate_limit_sleep = 5  # Sleep 5 seconds if rate limit hit

# Configuration: Tags to analyze (modify based on your interest)
TAGS_TO_ANALYZE = ["grpc", "rate-limiting", "go", "rust-cli", "postgresql"]
# Time window for question analysis (last 30 days)
TIME_WINDOW_DAYS = 30


def fetch_questions_for_tag(tag: str) -> pd.DataFrame:
    """Fetch all questions for a given tag within the configured time window."""
    logger.info(f"Fetching questions for tag: {tag}")
    start_date = datetime.now() - timedelta(days=TIME_WINDOW_DAYS)

    try:
        # Fetch questions with score, answer count, and accepted answer status
        questions, _ = SITE.fetch(
            "questions",
            tagged=tag,
            fromdate=int(start_date.timestamp()),
            sort="creation",
            order="desc",
            filter="!9Z(-wzftf"  # Filter to get score, answer_count, is_answered
        )
    except Exception as e:
        logger.error(f"Failed to fetch questions for {tag}: {e}")
        return pd.DataFrame()

    if not questions:
        logger.warning(f"No questions found for tag {tag}")
        return pd.DataFrame()

    # Convert to DataFrame for analysis
    df = pd.DataFrame(questions)
    df["creation_date"] = pd.to_datetime(df["creation_date"], unit="s")
    return df


def analyze_tag_underserved(df: pd.DataFrame, tag: str) -> Dict:
    """Analyze a tag's question data to determine if it's underserved."""
    if df.empty:
        return {"tag": tag, "is_underserved": False, "reason": "No questions found"}

    total_questions = len(df)
    avg_score = df["score"].mean()
    answer_rate = df["is_answered"].mean() * 100
    avg_answers = df["answer_count"].mean()

    # Check if tag meets underserved criteria
    is_underserved = (
        total_questions > 1000 / TIME_WINDOW_DAYS * 30  # >1000 questions/month
        and avg_score < 2
        and answer_rate < 60
    )

    return {
        "tag": tag,
        "total_questions": total_questions,
        "avg_score": round(avg_score, 2),
        "answer_rate": round(answer_rate, 2),
        "avg_answers": round(avg_answers, 2),
        "is_underserved": is_underserved,
        "recommendation": "Build OSS here" if is_underserved else "Avoid, well-served already"
    }


def main():
    """Main entry point for the analyzer."""
    logger.info(f"Starting analysis for tags: {TAGS_TO_ANALYZE}")
    results = []

    for tag in TAGS_TO_ANALYZE:
        # Rate limit: sleep 2 seconds between tag requests to avoid API limits
        time.sleep(2)
        df = fetch_questions_for_tag(tag)
        analysis = analyze_tag_underserved(df, tag)
        results.append(analysis)
        logger.info(f"Analysis for {tag}: {analysis['recommendation']}")

    # Convert results to DataFrame and print summary
    results_df = pd.DataFrame(results)
    print("\n=== Stack Overflow Underserved Problem Analysis ===")
    print(results_df[["tag", "total_questions", "avg_score", "answer_rate", "is_underserved", "recommendation"]].to_string(index=False))

    # Save results to CSV for reference
    output_path = "underserved_problems.csv"
    results_df.to_csv(output_path, index=False)
    logger.info(f"Results saved to {output_path}")


if __name__ == "__main__":
    main()

// Package ratelimit provides a gRPC unary and stream server interceptor for rate limiting
// using Redis as a backend. It is designed for production use with configurable limits,
// sliding window algorithm, and proper error handling.
package ratelimit

import (
    "context"
    "errors"
    "fmt"
    "time"

    "github.com/redis/go-redis/v9"
    "google.golang.org/grpc"
    "google.golang.org/grpc/codes"
    "google.golang.org/grpc/status"
)

// RateLimiterConfig holds configuration for the rate limiter
type RateLimiterConfig struct {
    // RedisClient is the Redis client used to store rate limit counters
    RedisClient *redis.Client
    // Limit is the maximum number of requests allowed per window
    Limit int64
    // Window is the time window for rate limiting (e.g., 1*time.Minute)
    Window time.Duration
    // KeyPrefix is the prefix used for Redis keys to avoid collisions
    KeyPrefix string
}

// RateLimiter implements gRPC rate limiting using a sliding window algorithm
type RateLimiter struct {
    config RateLimiterConfig
}

// NewRateLimiter creates a new RateLimiter with the given configuration
func NewRateLimiter(config RateLimiterConfig) (*RateLimiter, error) {
    if config.RedisClient == nil {
        return nil, errors.New("redis client is required")
    }
    if config.Limit <= 0 {
        return nil, errors.New("limit must be greater than 0")
    }
    if config.Window <= 0 {
        return nil, errors.New("window must be greater than 0")
    }
    if config.KeyPrefix == "" {
        config.KeyPrefix = "grpc_ratelimit:"
    }
    return &RateLimiter{config: config}, nil
}

// UnaryServerInterceptor returns a gRPC unary server interceptor that enforces rate limits
func (rl *RateLimiter) UnaryServerInterceptor() grpc.UnaryServerInterceptor {
    return func(
        ctx context.Context,
        req interface{},
        info *grpc.UnaryServerInfo,
        handler grpc.UnaryHandler,
    ) (interface{}, error) {
        // Extract client identifier (use method name + IP for simplicity; extend with auth context as needed)
        clientID := rl.extractClientID(ctx, info.FullMethod)
        allowed, err := rl.checkRateLimit(ctx, clientID)
        if err != nil {
            // Log error but allow request to proceed to avoid blocking on Redis failures
            fmt.Printf("rate limit check failed: %v\n", err)
            return handler(ctx, req)
        }
        if !allowed {
            return nil, status.Errorf(codes.ResourceExhausted, "rate limit exceeded: %d requests per %v", rl.config.Limit, rl.config.Window)
        }
        // Call the handler if rate limit passes
        return handler(ctx, req)
    }
}

// extractClientID creates a unique key for the client and method
func (rl *RateLimiter) extractClientID(ctx context.Context, method string) string {
    // In production, replace with authenticated user ID or API key from context
    // For this example, use peer address (simplified)
    peer, ok := grpc.PeerFromContext(ctx)
    if ok && peer.Addr != nil {
        return fmt.Sprintf("%s%s:%s", rl.config.KeyPrefix, method, peer.Addr.String())
    }
    // Fallback to method only if no peer address is available
    return fmt.Sprintf("%s%s:unknown", rl.config.KeyPrefix, method)
}

// checkRateLimit uses a sliding window algorithm with Redis sorted sets
func (rl *RateLimiter) checkRateLimit(ctx context.Context, key string) (bool, error) {
    now := time.Now().UnixNano()
    windowStart := now - rl.config.Window.Nanoseconds()

    // Use Redis pipeline to batch operations
    pipe := rl.config.RedisClient.Pipeline()

    // Remove entries older than the window start
    pipe.ZRemRangeByScore(ctx, key, "0", fmt.Sprintf("%d", windowStart))
    // Add current request to the sorted set
    pipe.ZAdd(ctx, key, redis.Z{Score: float64(now), Member: fmt.Sprintf("%d", now)})
    // Count number of entries in the window
    countCmd := pipe.ZCard(ctx, key)
    // Set key expiration to window * 2 to avoid stale keys
    pipe.Expire(ctx, key, rl.config.Window*2)

    _, err := pipe.Exec(ctx)
    if err != nil {
        return false, fmt.Errorf("redis pipeline failed: %w", err)
    }

    // Check if count exceeds limit
    return countCmd.Val() <= rl.config.Limit, nil
}

name: CI
on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-go@v5
        with:
          go-version: '1.22'
      - run: go test ./... -v
      - uses: golangci/golangci-lint-action@v6
        with:
          version: v1.59

// @Summary Rate limit a gRPC method
// @Description Applies sliding window rate limiting to a gRPC unary method
// @Param limit path int true "Max requests per window"
// @Param window path string true "Time window (e.g., 1m, 1h)"
// @Success 200 {object} string "Request allowed"
// @Failure 429 {object} string "Rate limit exceeded"
// @Router /rate-limit [get]
func (rl *RateLimiter) UnaryServerInterceptor() grpc.UnaryServerInterceptor { ... }

# .github/dependabot.yml
version: 2
updates:
  - package-ecosystem: "go"
    directory: "/"
    schedule:
      interval: "weekly"
    open-pull-requests-limit: 10

grpc-ratelimit/
├── .github/
│   ├── workflows/          # GitHub Actions CI/CD
│   │   └── ci.yml
│   ├── dependabot.yml       # Automated dependency updates
│   └── CONTRIBUTING.md      # Contributor guidelines
├── cmd/
│   └── example/             # Example usage of the rate limiter
│       └── main.go
├── internal/               # Private implementation details
│   └── redis/               # Redis client helpers
├── pkg/                     # Public package for import
│   └── ratelimit/           # Core rate limiter code
│       ├── ratelimit.go
│       └── ratelimit_test.go
├── docs/                    # Docusaurus documentation site
│   ├── getting-started.md
│   └── configuration.md
├── go.mod                   # Go module definition
├── go.sum                   # Go dependency checksums
├── README.md                # Project overview and quickstart
└── LICENSE                  # MIT License