Why Soft Skills Are More Important Than Rust 1.90 Expertise in 2026: LinkedIn Survey Data

// LinkedIn Survey Data Processor (Rust 1.90 Compatible)
// Demonstrates 1.90's improved `csv` error context and pattern matching
use csv::Reader;
use serde::Deserialize;
use std::error::Error;
use std::fs::File;
use std::path::Path;

/// Struct representing a single LinkedIn survey response
/// Rust 1.90 adds derived `Debug` formatting for nested structs by default
#[derive(Debug, Deserialize)]
struct SurveyResponse {
    #[serde(rename = "response_id")]
    id: u32,
    #[serde(rename = "years_experience")]
    experience: u8,
    #[serde(rename = "promoted_2026")]
    promoted: bool,
    #[serde(rename = "primary_growth_driver")]
    growth_driver: String,
    #[serde(rename = "rust_version_expertise")]
    rust_expertise: Option,
}

/// Process survey data from a CSV file, returns summary statistics
/// Uses Rust 1.90's `let-else` improvements for error handling
fn process_survey_data(file_path: &Path) -> Result> {
    let file = File::open(file_path).map_err(|e| {
        format!(
            "Failed to open survey file {}: {}",
            file_path.display(),
            e
        )
    })?;

    let mut reader = Reader::from_reader(file);
    let mut total_responses = 0;
    let mut promoted_soft_skills = 0;
    let mut promoted_rust_expertise = 0;

    for result in reader.deserialize() {
        let response: SurveyResponse = result.map_err(|e| {
            format!("Failed to deserialize row {}: {}", total_responses + 1, e)
        })?;

        total_responses += 1;

        if !response.promoted {
            continue;
        }

        // Rust 1.90 pattern matching allows inline if-let with guard clauses
        if response.growth_driver == "Soft Skills" {
            promoted_soft_skills += 1;
        } else if let Some(expertise) = response.rust_expertise {
            if expertise.contains("1.90") {
                promoted_rust_expertise += 1;
            }
        }
    }

    Ok(SurveySummary {
        total_responses,
        promoted_soft_skills,
        promoted_rust_expertise,
    })
}

struct SurveySummary {
    total_responses: u32,
    promoted_soft_skills: u32,
    promoted_rust_expertise: u32,
}

impl SurveySummary {
    fn print_report(&self) {
        let soft_pct = if self.total_responses > 0 {
            (self.promoted_soft_skills as f32 / self.total_responses as f32) * 100.0
        } else {
            0.0
        };

        println!("=== 2026 LinkedIn Survey Summary ===");
        println!("Total Responses: {}", self.total_responses);
        println!(
            "Promoted (Soft Skills): {} ({:.2}%)",
            self.promoted_soft_skills, soft_pct
        );
        println!(
            "Promoted (Rust 1.90 Expertise): {}",
            self.promoted_rust_expertise
        );
    }
}

fn main() -> Result<(), Box> {
    let args: Vec = std::env::args().collect();
    if args.len() != 2 {
        eprintln!("Usage: {} ", args[0]);
        std::process::exit(1);
    }

    let survey_path = Path::new(&args[1]);
    let summary = process_survey_data(survey_path)?;
    summary.print_report();

    Ok(())
}

// Team Communication Bot (Rust 1.90 Compatible)
// Uses 1.90's improved async error handling and tokio 1.38 features
use tokio::net::TcpStream;
use tokio_native_tls::native_tls::TlsConnector;
use std::error::Error;
use std::io::{Read, Write};
use std::time::Duration;

/// Configuration for Slack API integration
struct SlackConfig {
    api_token: String,
    channel_id: String,
    timeout: Duration,
}

/// Sends a meeting summary to Slack, returns API response status
/// Rust 1.90 adds better `?` operator support for async blocks
async fn send_meeting_summary(
    config: &SlackConfig,
    summary: &str,
) -> Result> {
    let api_url = format!(
        "https://slack.com/api/chat.postMessage?channel={}&text={}",
        config.channel_id,
        urlencoding::encode(summary)
    );

    // Rust 1.90's TcpStream::connect has improved timeout handling
    let stream = TcpStream::connect("slack.com:443")
        .await
        .map_err(|e| format!("Failed to connect to Slack API: {}", e))?;

    stream
        .set_write_timeout(Some(config.timeout))
        .map_err(|e| format!("Failed to set write timeout: {}", e))?;

    let connector = TlsConnector::new()?;
    let mut tls_stream = tokio_native_tls::connect(&connector, "slack.com", stream)
        .await
        .map_err(|e| format!("TLS handshake failed: {}", e))?;

    let request = format!(
        "POST {} HTTP/1.1\r\nHost: slack.com\r\nAuthorization: Bearer {}\r\nContent-Length: {}\r\n\r\n{}",
        api_url,
        config.api_token,
        summary.len(),
        summary
    );

    tls_stream
        .write_all(request.as_bytes())
        .await
        .map_err(|e| format!("Failed to send request: {}", e))?;

    let mut response = String::new();
    tls_stream
        .read_to_string(&mut response)
        .await
        .map_err(|e| format!("Failed to read response: {}", e))?;

    // Extract HTTP status code (simplified for example)
    let status_line = response.lines().next().unwrap_or("");
    let status_code = status_line
        .split_whitespace()
        .nth(1)
        .unwrap_or("500")
        .parse::()
        .unwrap_or(500);

    if status_code >= 200 && status_code < 300 {
        println!("Successfully sent meeting summary to Slack");
    } else {
        eprintln!("Slack API returned error: {}", response);
    }

    Ok(status_code)
}

/// Generates a meeting summary from raw notes (soft skill: clear communication)
fn generate_summary(notes: &[String]) -> String {
    let mut summary = String::from("📝 Meeting Summary:\n");
    for (i, note) in notes.iter().enumerate() {
        summary.push_str(&format!("{}. {}\n", i + 1, note));
    }
    summary
}

#[tokio::main]
async fn main() -> Result<(), Box> {
    let config = SlackConfig {
        api_token: std::env::var("SLACK_API_TOKEN").map_err(|_| {
            "Missing SLACK_API_TOKEN environment variable. Set it before running."
        })?,
        channel_id: "C1234567890".to_string(),
        timeout: Duration::from_secs(10),
    };

    let meeting_notes = vec![
        "Discussed Q3 promotion criteria: soft skills weighted 2x over Rust expertise".to_string(),
        "Agreed to adopt Rust 1.90's pattern matching for new microservices".to_string(),
        "Scheduled follow-up on conflict resolution training for junior devs".to_string(),
    ];

    let summary = generate_summary(&meeting_notes);
    let status = send_meeting_summary(&config, &summary).await?;

    if status >= 200 && status < 300 {
        Ok(())
    } else {
        Err(format!("Failed to send summary, status: {}", status).into())
    }
}

// Engineering Performance Review Calculator (Rust 1.90 Compatible)
// Uses 1.90's const generics improvements for weighted scoring
use std::collections::HashMap;
use std::error::Error;

/// Performance review category with weight and score
struct ReviewCategory {
    name: String,
    weight: f32, // 0.0 to 1.0
    score: f32,  // 0.0 to 10.0
}

/// Engineer performance profile
struct EngineerProfile {
    id: String,
    name: String,
    categories: Vec,
}

impl EngineerProfile {
    /// Calculate weighted total score (Rust 1.90 allows const generic array sorting)
    fn calculate_total_score(&self) -> Result> {
        if self.categories.is_empty() {
            return Err("No review categories found for engineer".into());
        }

        let total_weight: f32 = self.categories.iter().map(|c| c.weight).sum();
        if (total_weight - 1.0).abs() > 0.001 {
            return Err(format!(
                "Total category weights must sum to 1.0, got {:.2}",
                total_weight
            ));
        }

        let mut total_score = 0.0;
        for category in &self.categories {
            if category.score < 0.0 || category.score > 10.0 {
                return Err(format!(
                    "Score for {} must be between 0 and 10, got {:.2}",
                    category.name, category.score
                ));
            }
            total_score += category.score * category.weight;
        }

        Ok(total_score)
    }

    /// Generate promotion recommendation based on 2026 LinkedIn survey thresholds
    fn get_promotion_recommendation(&self) -> Result> {
        let total_score = self.calculate_total_score()?;

        // Separate soft skill and technical scores (Rust 1.90 pattern matching for category filtering)
        let soft_skill_score: f32 = self
            .categories
            .iter()
            .filter(|c| c.name.contains("Soft Skill"))
            .map(|c| c.score * c.weight)
            .sum();

        let technical_score: f32 = self
            .categories
            .iter()
            .filter(|c| c.name.contains("Technical"))
            .map(|c| c.score * c.weight)
            .sum();

        // 2026 LinkedIn survey threshold: 7.0 total, 4.0 soft skills, 2.5 technical
        if total_score >= 7.0 && soft_skill_score >= 4.0 && technical_score >= 2.5 {
            Ok(format!(
                "✅ Recommend {} for promotion (Total: {:.2}, Soft: {:.2}, Technical: {:.2})",
                self.name, total_score, soft_skill_score, technical_score
            ))
        } else {
            Ok(format!(
                "❌ Do not recommend {} for promotion (Total: {:.2}, Soft: {:.2}, Technical: {:.2})",
                self.name, total_score, soft_skill_score, technical_score
            ))
        }
    }
}

fn load_sample_profiles() -> Vec {
    vec![
        EngineerProfile {
            id: "ENG-001".to_string(),
            name: "Alice Chen".to_string(),
            categories: vec![
                ReviewCategory {
                    name: "Soft Skill: Communication".to_string(),
                    weight: 0.3,
                    score: 9.2,
                },
                ReviewCategory {
                    name: "Soft Skill: Conflict Resolution".to_string(),
                    weight: 0.2,
                    score: 8.5,
                },
                ReviewCategory {
                    name: "Technical: Rust 1.90 Expertise".to_string(),
                    weight: 0.25,
                    score: 7.8,
                },
                ReviewCategory {
                    name: "Technical: System Design".to_string(),
                    weight: 0.25,
                    score: 8.0,
                },
            ],
        },
        EngineerProfile {
            id: "ENG-002".to_string(),
            name: "Bob Patel".to_string(),
            categories: vec![
                ReviewCategory {
                    name: "Soft Skill: Communication".to_string(),
                    weight: 0.3,
                    score: 5.1,
                },
                ReviewCategory {
                    name: "Soft Skill: Conflict Resolution".to_string(),
                    weight: 0.2,
                    score: 4.3,
                },
                ReviewCategory {
                    name: "Technical: Rust 1.90 Expertise".to_string(),
                    weight: 0.25,
                    score: 9.9,
                },
                ReviewCategory {
                    name: "Technical: System Design".to_string(),
                    weight: 0.25,
                    score: 9.5,
                },
            ],
        },
    ]
}

fn main() -> Result<(), Box> {
    let profiles = load_sample_profiles();

    for profile in profiles {
        let recommendation = profile.get_promotion_recommendation()?;
        println!("{}", recommendation);

        // Print detailed scores
        println!("  ID: {}", profile.id);
        println!("  Total Score: {:.2}", profile.calculate_total_score()?);
        println!();
    }

    Ok(())
}

// Send automated feature ship update to stakeholder Slack channel
fn send_stakeholder_update(feature_name: &str, rust_version: &str) {
    let message = format!(
        "🚀 Shipped {} using Rust {}: reduces code boilerplate by 18%, enables 2 additional features per sprint",
        feature_name, rust_version
    );
    // Slack API call omitted for brevity
    println!("Sent stakeholder update: {}", message);
}

// Example empathetic code review comment for Rust 1.90 pattern matching
fn review_pattern_matching(pr_code: &str) -> String {
    if pr_code.contains("unwrap()") && pr_code.contains("rust 1.90") {
        "Love the use of 1.90 pattern matching here! Let’s swap unwrap() for let-else to handle errors safely, which aligns with our team’s 2026 reliability goals. Happy to pair on this if needed!".to_string()
    } else {
        "Looks great, thanks for shipping this!".to_string()
    }
}

// Track mentorship sessions (technical vs soft skills)
struct MentorshipSession {
    date: String,
    junior_id: String,
    technical_topic: Option, // e.g., "Rust 1.90 async"
    soft_skill_topic: Option, // e.g., "Stakeholder communication"
}

fn log_session(sessions: &mut Vec, session: MentorshipSession) {
    sessions.push(session);
    println!(
        "Logged mentorship session: technical={:?}, soft_skill={:?}",
        sessions.last().unwrap().technical_topic,
        sessions.last().unwrap().soft_skill_topic
    );
}