Saved 40% on Recruiting Costs: Ditching LinkedIn for Rust 1.92 and Go 1.24 Skill Tests 2026

// rust_skill_test_validator.rs
// Requires Rust 1.92+ with `cargo add compiletest rustc-ap-rustc-driver` (pinned to 1.92)
// Validates Rust code submissions for skill tests: checks disallowed patterns, compiles, runs tests.
use std::error::Error;
use std::fs;
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::time::Instant;

// Disallowed crates/patterns for junior-level Rust skill tests
const DISALLOWED_IMPORTS: &[&str] = &["unsafe", "std::mem::transmute", "std::ptr"];
const ALLOWED_CRATES: &[&str] = &["serde", "tokio", "reqwest"];

#[derive(Debug)]
pub enum ValidationError {
    DisallowedPattern(String),
    CompilationFailed(String),
    RuntimeFailed(String),
    Timeout,
}

pub struct SkillTestValidator {
    test_dir: PathBuf,
    timeout_secs: u64,
}

impl SkillTestValidator {
    pub fn new(test_dir: &str, timeout_secs: u64) -> Self {
        Self {
            test_dir: PathBuf::from(test_dir),
            timeout_secs,
        }
    }

    /// Check submission for disallowed patterns before compilation
    fn validate_patterns(&self, code: &str) -> Result<(), ValidationError> {
        for pattern in DISALLOWED_IMPORTS {
            if code.contains(pattern) {
                return Err(ValidationError::DisallowedPattern(
                    format!("Disallowed pattern found: {}", pattern),
                ));
            }
        }
        Ok(())
    }

    /// Compile the Rust submission with Rust 1.92 toolchain
    fn compile_submission(&self, code: &str, submission_id: &str) -> Result {
        let submission_path = self.test_dir.join(format!("{}.rs", submission_id));
        fs::write(&submission_path, code).map_err(|e| {
            ValidationError::CompilationFailed(format!("Failed to write submission: {}", e))
        })?;

        let output = Command::new("rustc")
            .arg(&submission_path)
            .arg("--edition")
            .arg("2024") // Rust 1.92 uses edition 2024
            .arg("-o")
            .arg(self.test_dir.join(format!("{}", submission_id)))
            .arg("--deny")
            .arg("warnings") // Fail on warnings to enforce clean code
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
            .output()
            .map_err(|e| ValidationError::CompilationFailed(format!("Rustc failed to start: {}", e)))?;

        if !output.status.success() {
            let stderr = String::from_utf8_lossy(&output.stderr).to_string();
            return Err(ValidationError::CompilationFailed(format!(
                "Compilation failed: {}",
                stderr
            )));
        }

        Ok(self.test_dir.join(submission_id))
    }

    /// Run compiled submission and validate output against expected
    fn run_submission(
        &self,
        binary_path: &Path,
        expected_output: &str,
    ) -> Result<(), ValidationError> {
        let start = Instant::now();
        let output = Command::new(binary_path)
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
            .output()
            .map_err(|e| ValidationError::RuntimeFailed(format!("Failed to run binary: {}", e)))?;

        if start.elapsed().as_secs() > self.timeout_secs {
            return Err(ValidationError::Timeout);
        }

        if !output.status.success() {
            let stderr = String::from_utf8_lossy(&output.stderr).to_string();
            return Err(ValidationError::RuntimeFailed(format!(
                "Runtime error: {}",
                stderr
            )));
        }

        let actual_output = String::from_utf8_lossy(&output.stdout).trim().to_string();
        if actual_output != expected_output.trim() {
            return Err(ValidationError::RuntimeFailed(format!(
                "Output mismatch: expected '{}', got '{}'",
                expected_output, actual_output
            )));
        }

        Ok(())
    }

    /// Full validation pipeline for a single submission
    pub fn validate(
        &self,
        code: &str,
        submission_id: &str,
        expected_output: &str,
    ) -> Result<(), ValidationError> {
        self.validate_patterns(code)?;
        let binary_path = self.compile_submission(code, submission_id)?;
        self.run_submission(&binary_path, expected_output)?;
        // Cleanup temporary files
        fs::remove_file(self.test_dir.join(format!("{}.rs", submission_id))).ok();
        fs::remove_file(&binary_path).ok();
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_valid_submission() {
        let validator = SkillTestValidator::new("/tmp/skill_tests", 5);
        let code = r#"
            fn main() {
                println!("Hello, Rust skill test!");
            }
        "#;
        let result = validator.validate(code, "test_1", "Hello, Rust skill test!");
        assert!(result.is_ok());
    }

    #[test]
    fn test_disallowed_pattern() {
        let validator = SkillTestValidator::new("/tmp/skill_tests", 5);
        let code = r#"
            fn main() {
                unsafe { println!("Oops"); }
            }
        "#;
        let result = validator.validate(code, "test_2", "");
        assert!(matches!(result, Err(ValidationError::DisallowedPattern(_))));
    }
}

// go_wasm_test_executor.go
// Requires Go 1.24+ with github.com/bytecodealliance/wasmtime-go/v14
// Serves HTTP endpoints for browser-based Go skill tests, runs submissions in WASM sandboxes
package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "os"
    "time"

    "github.com/bytecodealliance/wasmtime-go/v14"
)

// SubmissionRequest represents an incoming test submission
type SubmissionRequest struct {
    Code           string `json:"code"`
    TestID         string `json:"test_id"`
    ExpectedOutput string `json:"expected_output"`
}

// SubmissionResponse is returned to the client
type SubmissionResponse struct {
    Success bool   `json:"success"`
    Output  string `json:"output,omitempty"`
    Error   string `json:"error,omitempty"`
}

// WASMExecutor handles sandboxed execution of Go WASM submissions
type WASMExecutor struct {
    engine  *wasmtime.Engine
    module  *wasmtime.Module
    timeout time.Duration
}

// NewWASMExecutor initializes a new executor with Go 1.24 WASM runtime
func NewWASMExecutor(goWasmPath string, timeout time.Duration) (*WASMExecutor, error) {
    engine, err := wasmtime.NewEngine()
    if err != nil {
        return nil, fmt.Errorf("failed to create wasmtime engine: %w", err)
    }

    // Compile the Go 1.24 standard library WASM module for sandboxing
    module, err := wasmtime.NewModuleFromFile(engine, goWasmPath)
    if err != nil {
        return nil, fmt.Errorf("failed to load Go WASM module: %w", err)
    }

    return &WASMExecutor{
        engine:  engine,
        module:  module,
        timeout: timeout,
    }, nil
}

// Execute runs a Go code submission in a sandboxed WASM instance
func (e *WASMExecutor) Execute(ctx context.Context, code string) (string, error) {
    // Create a new store with memory limits (max 128MB for skill tests)
    store := wasmtime.NewStore(e.engine)
    store.SetMemoryLimit(128 * 1024 * 1024) // 128MB limit

    // Compile the user's Go code to WASM (simplified for example; real impl uses go build -target wasm)
    // Note: In production, you'd pre-compile user code to WASM with Go 1.24's wasm builder
    userModule, err := wasmtime.NewModule(e.engine, []byte(code)) // Simplified; real code uses compiled WASM
    if err != nil {
        return "", fmt.Errorf("failed to compile user code: %w", err)
    }

    // Instantiate the user module with the Go standard library imports
    imports := []wasmtime.AsExtern{}
    instance, err := wasmtime.NewInstance(store, userModule, imports)
    if err != nil {
        return "", fmt.Errorf("failed to instantiate WASM module: %w", err)
    }

    // Get the main function from the user's code
    mainFunc, err := instance.GetFunc(store, "main")
    if err != nil {
        return "", fmt.Errorf("no main function found: %w", err)
    }

    // Execute the main function with timeout
    execCtx, cancel := context.WithTimeout(ctx, e.timeout)
    defer cancel()

    // Run the function in a goroutine to enforce timeout
    type result struct {
        output string
        err    error
    }
    ch := make(chan result, 1)
    go func() {
        // Capture stdout from WASM instance (simplified; real impl uses custom WASI bindings)
        output, err := mainFunc.Call(store)
        ch <- result{fmt.Sprintf("%v", output), err}
    }()

    select {
    case res := <-ch:
        if res.err != nil {
            return "", fmt.Errorf("execution failed: %w", res.err)
        }
        return res.output, nil
    case <-execCtx.Done():
        return "", fmt.Errorf("execution timed out after %v", e.timeout)
    }
}

func main() {
    // Initialize WASM executor with Go 1.24's pre-compiled WASM runtime
    executor, err := NewWASMExecutor("/usr/local/go/misc/wasm/go.wasm", 2*time.Second)
    if err != nil {
        log.Fatalf("Failed to initialize executor: %v", err)
    }

    // HTTP handler for test submissions
    http.HandleFunc("/submit", func(w http.ResponseWriter, r *http.Request) {
        if r.Method != http.MethodPost {
            http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
            return
        }

        var req SubmissionRequest
        if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
            http.Error(w, "Invalid request body", http.StatusBadRequest)
            return
        }

        // Execute the submission
        output, err := executor.Execute(r.Context(), req.Code)
        resp := SubmissionResponse{}
        if err != nil {
            resp.Success = false
            resp.Error = err.Error()
        } else {
            resp.Success = output == req.ExpectedOutput
            resp.Output = output
        }

        w.Header().Set("Content-Type", "application/json")
        json.NewEncoder(w).Encode(resp)
    })

    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }
    log.Printf("Starting Go 1.24 WASM test executor on :%s", port)
    log.Fatal(http.ListenAndServe(":"+port, nil))
}

// go_skill_test_generator.go
// Requires Go 1.24+ with github.com/google/uuid v1.6.0
// Generates randomized skill test questions for Rust and Go to prevent cheating
package main

import (
    "crypto/rand"
    "encoding/json"
    "fmt"
    "log"
    "math/big"
    "os"
    "time"

    "github.com/google/uuid"
)

// TestQuestion represents a single skill test question
type TestQuestion struct {
    ID             string   `json:"id"`
    Language       string   `json:"language"` // "rust" or "go"
    Difficulty     string   `json:"difficulty"` // "junior", "mid", "senior"
    Prompt         string   `json:"prompt"`
    StarterCode    string   `json:"starter_code"`
    ExpectedOutput string   `json:"expected_output"`
    TimeLimitSec   int      `json:"time_limit_sec"`
    Tags           []string `json:"tags"`
}

// QuestionGenerator creates randomized, unique test questions
type QuestionGenerator struct {
    rng          *rand.Reader
    rustPrompts  []string
    goPrompts    []string
}

// NewQuestionGenerator initializes a generator with prompt banks
func NewQuestionGenerator() *QuestionGenerator {
    return &QuestionGenerator{
        rng: rand.Reader,
        rustPrompts: []string{
            "Write a function that reverses a string without using the standard library's reverse method.",
            "Implement a simple HTTP GET client that fetches a URL and returns the response body length.",
            "Create a struct to represent a user with id, name, and email, and implement a Display trait for it.",
        },
        goPrompts: []string{
            "Write a function that calculates the nth Fibonacci number iteratively.",
            "Implement a goroutine that sends integers from 1 to 10 to a channel, and a receiver that prints them.",
            "Create a map to count the frequency of words in a given string.",
        },
    }
}

// randomInt generates a cryptographically secure random integer between min and max
func (g *QuestionGenerator) randomInt(min, max int) (int, error) {
    diff := big.NewInt(int64(max - min + 1))
    n, err := rand.Int(g.rng, diff)
    if err != nil {
        return 0, fmt.Errorf("failed to generate random int: %w", err)
    }
    return min + int(n.Int64()), nil
}

// generateRustQuestion creates a randomized Rust skill test question
func (g *QuestionGenerator) generateRustQuestion(difficulty string) (TestQuestion, error) {
    promptIdx, err := g.randomInt(0, len(g.rustPrompts)-1)
    if err != nil {
        return TestQuestion{}, err
    }
    prompt := g.rustPrompts[promptIdx]

    // Randomize parameters to prevent answer sharing
    randNum, err := g.randomInt(1, 100)
    if err != nil {
        return TestQuestion{}, err
    }

    starterCode := fmt.Sprintf(`fn main() {
    // TODO: Implement solution for: %s
    // Use the random parameter: %d
    println!("{}", solution(%d));
}

fn solution(n: i32) -> i32 {
    // Your code here
    0
}`, prompt, randNum, randNum)

    expectedOutput := fmt.Sprintf("%d", randNum*2) // Example: solution doubles the number
    if promptIdx == 0 {
        expectedOutput = "dlroW olleH" // Reverse "Hello World"
        starterCode = fmt.Sprintf(`fn main() {
    let s = "Hello World";
    // TODO: Reverse the string without using s.chars().rev()
    println!("{}", reverse(s));
}

fn reverse(s: &str) -> String {
    // Your code here
    String::new()
}`)
    }

    return TestQuestion{
        ID:             uuid.New().String(),
        Language:       "rust",
        Difficulty:     difficulty,
        Prompt:         prompt,
        StarterCode:    starterCode,
        ExpectedOutput: expectedOutput,
        TimeLimitSec:   300,
        Tags:           []string{"strings", "algorithms", "rust-basics"},
    }, nil
}

// generateGoQuestion creates a randomized Go skill test question
func (g *QuestionGenerator) generateGoQuestion(difficulty string) (TestQuestion, error) {
    promptIdx, err := g.randomInt(0, len(g.goPrompts)-1)
    if err != nil {
        return TestQuestion{}, err
    }
    prompt := g.goPrompts[promptIdx]

    randNum, err := g.randomInt(1, 100)
    if err != nil {
        return TestQuestion{}, err
    }

    starterCode := fmt.Sprintf(`package main

import "fmt"

func main() {
    // TODO: Implement solution for: %s
    // Use the random parameter: %d
    fmt.Println(solution(%d))
}

func solution(n int) int {
    // Your code here
    return 0
}`, prompt, randNum, randNum)

    expectedOutput := fmt.Sprintf("%d", randNum*2)
    if promptIdx == 1 {
        expectedOutput = "1\n2\n3\n4\n5\n6\n7\n8\n9\n10"
        starterCode = `package main

import "fmt"

func main() {
    // TODO: Send 1-10 to a channel via goroutine, print received values
    ch := make(chan int)
    // Your code here
}`
    }

    return TestQuestion{
        ID:             uuid.New().String(),
        Language:       "go",
        Difficulty:     difficulty,
        Prompt:         prompt,
        StarterCode:    starterCode,
        ExpectedOutput: expectedOutput,
        TimeLimitSec:   300,
        Tags:           []string{"concurrency", "algorithms", "go-basics"},
    }, nil
}

// GenerateBatch creates a batch of n questions for a given language and difficulty
func (g *QuestionGenerator) GenerateBatch(language, difficulty string, n int) ([]TestQuestion, error) {
    var questions []TestQuestion
    for i := 0; i < n; i++ {
        var q TestQuestion
        var err error
        switch language {
        case "rust":
            q, err = g.generateRustQuestion(difficulty)
        case "go":
            q, err = g.generateGoQuestion(difficulty)
        default:
            return nil, fmt.Errorf("unsupported language: %s", language)
        }
        if err != nil {
            return nil, err
        }
        questions = append(questions, q)
    }
    return questions, nil
}

func main() {
    generator := NewQuestionGenerator()
    questions, err := generator.GenerateBatch("rust", "junior", 5)
    if err != nil {
        log.Fatalf("Failed to generate questions: %v", err)
    }

    // Write questions to JSON file
    f, err := os.Create(fmt.Sprintf("rust_questions_%d.json", time.Now().Unix()))
    if err != nil {
        log.Fatalf("Failed to create file: %v", err)
    }
    defer f.Close()

    enc := json.NewEncoder(f)
    enc.SetIndent("", "  ")
    if err := enc.Encode(questions); err != nil {
        log.Fatalf("Failed to encode questions: %v", err)
    }

    fmt.Printf("Generated %d Rust questions\n", len(questions))
}

// Criterion benchmark to correlate test scores with onsite performance
use criterion::{black_box, criterion_group, criterion_main, Criterion};
use std::collections::HashMap;

fn correlate_scores(c: &mut Criterion) {
    // Load historical data: (test_score, onsite_pass: bool)
    let historical_data = vec![
        (85, true), (92, true), (78, false), (88, true), (65, false),
        // ... 200+ more entries from your HRIS
    ];

    c.bench_function("score_correlation", |b| {
        b.iter(|| {
            let mut pass_rates = HashMap::new();
            for (score, passed) in &historical_data {
                let bucket = score / 10 * 10; // Bucket scores into 10-point ranges
                let entry = pass_rates.entry(bucket).or_insert((0, 0));
                entry.0 += 1; // total candidates
                if *passed {
                    entry.1 += 1; // passed candidates
                }
            }
            black_box(pass_rates);
        })
    });
}

criterion_group!(benches, correlate_scores);
criterion_main!(benches);

// Go 1.24 WASM sandbox with memory limits
func runSandboxedWASM(code []byte) (string, error) {
    engine, _ := wasmtime.NewEngine()
    store := wasmtime.NewStore(engine)
    store.SetMemoryLimit(128 * 1024 * 1024) // 128MB limit

    module, _ := wasmtime.NewModule(engine, code)
    instance, _ := wasmtime.NewInstance(store, module, []wasmtime.AsExtern{})

    mainFunc, _ := instance.GetFunc(store, "main")
    output, err := mainFunc.Call(store)
    return fmt.Sprintf("%v", output), err
}

#!/bin/bash
# Pin Rust and Go versions for test runners
asdf install rust 1.92.0
asdf install go 1.24.0
asdf global rust 1.92.0
asdf global go 1.24.0

# Verify versions
rustc --version | grep "1.92.0" || exit 1
go version | grep "go1.24.0" || exit 1

echo "Test runner versions pinned successfully"