Step-by-Step Guide to Switching from Java 21 to Rust 1.84 in 6 Months for Better Job Prospects

// Java 21 dependency audit script using jdeps
// Run with: java --module-path $JAVA_HOME/lib/jmods -m jdk.jdeps/jdk.tools.jdeps.Main --multi-release 21 -verbose:class -dotoutput ./jdeps-output ./target/my-app.jar

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.jar.JarFile;
import java.util.jar.Manifest;

public class JdepsAudit {
    public static void main(String[] args) throws IOException {
        if (args.length != 1) {
            System.err.println("Usage: java JdepsAudit ");
            System.exit(1);
        }

        String jarPath = args[0];
        File jarFile = new File(jarPath);
        if (!jarFile.exists() || !jarFile.isFile()) {
            System.err.println("Invalid JAR path: " + jarPath);
            System.exit(1);
        }

        // Read JAR manifest to get main class and dependencies
        Manifest manifest;
        try (JarFile jar = new JarFile(jarFile)) {
            manifest = jar.getManifest();
        }
        if (manifest != null) {
            System.out.println("Main-Class: " + manifest.getMainAttributes().getValue("Main-Class"));
            System.out.println("Class-Path: " + manifest.getMainAttributes().getValue("Class-Path"));
        }

        // List all class files in JAR
        List classFiles = new ArrayList<>();
        try (JarFile jar = new JarFile(jarFile)) {
            jar.stream().forEach(entry -> {
                if (entry.getName().endsWith(".class")) {
                    classFiles.add(entry.getName());
                }
            });
        }
        System.out.println("Total class files: " + classFiles.size());

        // Write class list to file for jdeps analysis
        Path outputPath = Path.of("class-list.txt");
        Files.write(outputPath, classFiles);
        System.out.println("Class list written to " + outputPath.toAbsolutePath());

        // Run jdeps command (simplified, in production use ProcessBuilder)
        System.out.println("Run jdeps with: jdeps --multi-release 21 -verbose:class -dotoutput ./jdeps-output " + jarPath);
    }
}

// Rust 1.84 concept mapping reference for Java 21 developers
// Run with: cargo run
// Add to Cargo.toml: rustc_version = "0.4.0"

use std::collections::HashMap;

struct ConceptMapping {
    java_concept: String,
    rust_equivalent: String,
    notes: String,
}

fn main() {
    let mappings = vec![
        ConceptMapping {
            java_concept: "Virtual Thread (Project Loom)".to_string(),
            rust_equivalent: "Tokio async task".to_string(),
            notes: "Both provide lightweight concurrency, Rust requires explicit async/await".to_string(),
        },
        ConceptMapping {
            java_concept: "Maven/Gradle".to_string(),
            rust_equivalent: "Cargo".to_string(),
            notes: "Cargo handles build, dependency management, and testing".to_string(),
        },
        ConceptMapping {
            java_concept: "HashMap (java.util)".to_string(),
            rust_equivalent: "HashMap (std::collections) / DashMap".to_string(),
            notes: "DashMap provides concurrent access without Mutex".to_string(),
        },
        ConceptMapping {
            java_concept: "Spring Boot".to_string(),
            rust_equivalent: "Axum / Actix-web".to_string(),
            notes: "Axum is async-first, similar to Spring WebFlux".to_string(),
        },
        ConceptMapping {
            java_concept: "JMH (benchmarking)".to_string(),
            rust_equivalent: "Criterion".to_string(),
            notes: "Criterion provides statistical significance testing".to_string(),
        },
        ConceptMapping {
            java_concept: "IntelliJ IDEA".to_string(),
            rust_equivalent: "IntelliJ Rust plugin".to_string(),
            notes: "Full IDE support in existing IntelliJ workflows".to_string(),
        },
        ConceptMapping {
            java_concept: "NullPointerException".to_string(),
            rust_equivalent: "Option type".to_string(),
            notes: "Rust eliminates nulls, forces handling missing values".to_string(),
        },
        ConceptMapping {
            java_concept: "Checked exceptions".to_string(),
            rust_equivalent: "Result type".to_string(),
            notes: "Forces error handling at compile time".to_string(),
        },
    ];

    println!("{:<40} {:<40} {}", "Java Concept", "Rust Equivalent", "Notes");
    println!("{}", "-".repeat(120));
    for mapping in mappings {
        println!("{:<40} {:<40} {}", mapping.java_concept, mapping.rust_equivalent, mapping.notes);
    }

    // Print Rust 1.84 version info
    println!("\nRust version: {}", rustc_version::version().unwrap());
}

// Java 21 Virtual Threads Auth Service (original)
// Compile with: javac UserAuthService.java
// Run with: java UserAuthService

import com.sun.net.httpserver.HttpServer;
import java.net.InetSocketAddress;
import java.util.concurrent.Executors;
import java.util.concurrent.ConcurrentHashMap;
import java.util.UUID;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.io.IOException;
import java.io.InputStream;

public class UserAuthService {
    private static final ConcurrentHashMap userSessions = new ConcurrentHashMap<>();
    private static final int PORT = 8080;

    public static void main(String[] args) throws Exception {
        HttpServer server = HttpServer.create(new InetSocketAddress(PORT), 0);
        // Java 21 virtual thread executor
        server.setExecutor(Executors.newVirtualThreadPerTaskExecutor());

        // Login endpoint
        server.createContext("/login", exchange -> {
            if (!exchange.getRequestMethod().equals("POST")) {
                exchange.sendResponseHeaders(405, -1);
                exchange.close();
                return;
            }
            try {
                // Read request body
                InputStream requestBody = exchange.getRequestBody();
                byte[] bodyBytes = requestBody.readAllBytes();
                String[] credentials = new String(bodyBytes).split(":");
                if (credentials.length != 2) {
                    exchange.sendResponseHeaders(400, -1);
                    exchange.close();
                    return;
                }
                String username = credentials[0];
                String password = hashPassword(credentials[1]);

                // Hardcoded demo user
                if (username.equals("admin") && password.equals(hashPassword("password123"))) {
                    String sessionId = UUID.randomUUID().toString();
                    userSessions.put(sessionId, username);
                    String response = "Session ID: " + sessionId;
                    exchange.sendResponseHeaders(200, response.length());
                    exchange.getResponseBody().write(response.getBytes());
                } else {
                    exchange.sendResponseHeaders(401, -1);
                }
            } catch (Exception e) {
                exchange.sendResponseHeaders(500, -1);
            } finally {
                exchange.close();
            }
        });

        // Validate session endpoint
        server.createContext("/validate", exchange -> {
            if (!exchange.getRequestMethod().equals("GET")) {
                exchange.sendResponseHeaders(405, -1);
                exchange.close();
                return;
            }
            String sessionId = exchange.getRequestHeaders().getFirst("Session-ID");
            if (sessionId == null || !userSessions.containsKey(sessionId)) {
                exchange.sendResponseHeaders(401, -1);
                exchange.close();
                return;
            }
            String response = "Valid session for user: " + userSessions.get(sessionId);
            exchange.sendResponseHeaders(200, response.length());
            try {
                exchange.getResponseBody().write(response.getBytes());
            } catch (IOException e) {
                // Ignore
            } finally {
                exchange.close();
            }
        });

        System.out.println("Java 21 Auth Server running on port " + PORT);
        server.start();
    }

    private static String hashPassword(String password) {
        try {
            MessageDigest md = MessageDigest.getInstance("SHA-256");
            byte[] hash = md.digest(password.getBytes());
            StringBuilder hex = new StringBuilder();
            for (byte b : hash) {
                hex.append(String.format("%02x", b));
            }
            return hex.toString();
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
    }
}

// Rust 1.84 Axum Auth Service (rewritten)
// Add to Cargo.toml:
// [dependencies]
// axum = "0.7.5"
// tokio = { version = "1.37", features = ["full"] }
// dashmap = "5.5.3"
// sha2 = "0.10.8"
// uuid = { version = "1.7.0", features = ["v4"] }
// hex = "0.4.3"

use axum::{
    Router,
    routing::{post, get},
    extract::Request,
    http::{StatusCode, header},
    response::IntoResponse,
};
use dashmap::DashMap;
use sha2::{Sha256, Digest};
use uuid::Uuid;
use std::sync::Arc;

// Concurrent session store
type SessionStore = Arc>;

fn hash_password(password: &str) -> String {
    let mut hasher = Sha256::new();
    hasher.update(password.as_bytes());
    hex::encode(hasher.finalize())
}

async fn login_handler(
    headers: header::HeaderMap,
    body: Request,
) -> impl IntoResponse {
    // Reject non-POST requests
    if headers.get(header::ALLOW).is_some() {
        return (StatusCode::METHOD_NOT_ALLOWED, "Only POST allowed").into_response();
    }

    let session_store = body.extensions().get::().unwrap().clone();

    // Read request body (1MB limit)
    let body_bytes = axum::body::to_bytes(body.into_body(), 1024 * 1024)
        .await
        .map_err(|_| (StatusCode::BAD_REQUEST, "Invalid request body"))?;

    let credentials = String::from_utf8(body_bytes.to_vec())
        .map_err(|_| (StatusCode::BAD_REQUEST, "Invalid UTF-8"))?;

    let parts: Vec<&str> = credentials.split(':').collect();
    if parts.len() != 2 {
        return (StatusCode::BAD_REQUEST, "Credentials must be username:password").into_response();
    }

    let username = parts[0];
    let password_hash = hash_password(parts[1]);

    // Hardcoded demo user
    if username == "admin" && password_hash == hash_password("password123") {
        let session_id = Uuid::new_v4().to_string();
        session_store.insert(session_id.clone(), username.to_string());
        (StatusCode::OK, format!("Session ID: {}", session_id)).into_response()
    } else {
        (StatusCode::UNAUTHORIZED, "Invalid credentials").into_response()
    }
}

async fn validate_handler(
    headers: header::HeaderMap,
    session_store: SessionStore,
) -> impl IntoResponse {
    let session_id = match headers.get("Session-ID") {
        Some(id) => id.to_str().unwrap_or(""),
        None => return (StatusCode::UNAUTHORIZED, "Missing Session-ID header").into_response(),
    };

    match session_store.get(session_id) {
        Some(user) => (StatusCode::OK, format!("Valid session for user: {}", user)).into_response(),
        None => (StatusCode::UNAUTHORIZED, "Invalid session").into_response(),
    }
}

#[tokio::main]
async fn main() {
    let session_store: SessionStore = Arc::new(DashMap::new());

    let app = Router::new()
        .route("/login", post(login_handler))
        .route("/validate", get(validate_handler))
        .with_state(session_store);

    let listener = tokio::net::TcpListener::bind("0.0.0.0:8080").await.unwrap();
    println!("Rust 1.84 Auth Server running on port 8080");

    axum::serve(listener, app).await.unwrap();
}

// Rust 1.84 AWS Lambda Auth Handler (expanded deployment)
// Add to Cargo.toml:
// [dependencies]
// lambda_runtime = "0.8.2"
// aws_lambda_events = "0.12.0"
// serde_json = "1.0.113"
// tokio = { version = "1.37", features = ["full"] }
// dashmap = "5.5.3"
// sha2 = "0.10.8"
// uuid = "1.7.0"
// hex = "0.4.3"

use lambda_runtime::{service_fn, LambdaEvent, Error};
use aws_lambda_events::apigw::{ApiGatewayProxyRequest, ApiGatewayProxyResponse};
use dashmap::DashMap;
use sha2::{Sha256, Digest};
use uuid::Uuid;
use std::sync::Arc;
use serde_json::json;

type SessionStore = Arc>;

fn hash_password(password: &str) -> String {
    let mut hasher = Sha256::new();
    hasher.update(password.as_bytes());
    hex::encode(hasher.finalize())
}

async fn login_handler(store: SessionStore, body: Option) -> ApiGatewayProxyResponse {
    let credentials = match body {
        Some(b) => b,
        None => return bad_request("Missing request body"),
    };

    let parts: Vec<&str> = credentials.split(':').collect();
    if parts.len() != 2 {
        return bad_request("Credentials must be username:password");
    }

    let username = parts[0];
    let password_hash = hash_password(parts[1]);

    if username == "admin" && password_hash == hash_password("password123") {
        let session_id = Uuid::new_v4().to_string();
        store.insert(session_id.clone(), username.to_string());
        ok_response(json!({ "session_id": session_id }))
    } else {
        unauthorized("Invalid credentials")
    }
}

async fn validate_handler(store: SessionStore, headers: Option>) -> ApiGatewayProxyResponse {
    let session_id = match headers {
        Some(h) => h.iter().find(|(k, _)| k.to_lowercase() == "session-id").map(|(_, v)| v.clone()),
        None => return unauthorized("Missing Session-ID header"),
    };

    match session_id {
        Some(id) => match store.get(&id) {
            Some(user) => ok_response(json!({ "user": user.clone(), "valid": true })),
            None => unauthorized("Invalid session"),
        },
        None => unauthorized("Missing Session-ID header"),
    }
}

fn ok_response(body: serde_json::Value) -> ApiGatewayProxyResponse {
    ApiGatewayProxyResponse {
        status_code: 200,
        headers: Default::default(),
        multi_value_headers: Default::default(),
        body: Some(serde_json::to_string(&body).unwrap().into()),
        is_base64_encoded: false,
    }
}

fn bad_request(msg: &str) -> ApiGatewayProxyResponse {
    ApiGatewayProxyResponse {
        status_code: 400,
        headers: Default::default(),
        multi_value_headers: Default::default(),
        body: Some(json!({ "error": msg }).to_string().into()),
        is_base64_encoded: false,
    }
}

fn unauthorized(msg: &str) -> ApiGatewayProxyResponse {
    ApiGatewayProxyResponse {
        status_code: 401,
        headers: Default::default(),
        multi_value_headers: Default::default(),
        body: Some(json!({ "error": msg }).to_string().into()),
        is_base64_encoded: false,
    }
}

async fn handler(
    event: LambdaEvent,
    store: SessionStore,
) -> Result {
    let request = event.payload;

    match request.path.as_deref() {
        Some("/login") => {
            let body = request.body.clone();
            Ok(login_handler(store, body).await)
        }
        Some("/validate") => {
            let headers = request.headers.clone();
            Ok(validate_handler(store, headers).await)
        }
        _ => Ok(bad_request("Invalid path")),
    }
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    let session_store: SessionStore = Arc::new(DashMap::new());
    let store_clone = session_store.clone();

    lambda_runtime::run(service_fn(move |event| {
        let store = store_clone.clone();
        handler(event, store)
    }))
    .await?;

    Ok(())
}

// Rust 1.84 Cover Letter Generator for Job Applications
// Add to Cargo.toml:
// [dependencies]
// reqwest = { version = "0.12.0", features = ["json"] }
// serde = "1.0.0"
// serde_json = "1.0.0"

use reqwest::header;
use serde_json::json;
use std::io::{self, Write};

#[tokio::main]
async fn main() -> Result<(), Box> {
    let client = reqwest::Client::new();

    // Fetch Rust job postings (simplified, use LinkedIn API in production)
    let job_url = "https://www.linkedin.com/jobs/search?keywords=rust%20developer&location=United%20States";
    let response = client
        .get(job_url)
        .header(header::USER_AGENT, "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36")
        .send()
        .await?;

    println!("Fetched job search page: status {}", response.status());

    // Generate sample cover letter
    let cover_letter = r#"
Dear Hiring Manager,

I am writing to express my interest in the Senior Rust Developer role at [Company]. With 15 years of experience in Java backend development and 6 months of hands-on experience migrating Java 21 services to Rust 1.84, I have reduced cloud costs by 40% and improved p99 latency by 3x in production systems.

My recent projects include rewriting a Spring Boot auth service to Axum/Tokio, cutting runtime memory from 210MB to 42MB for 10k concurrent requests. I have experience with Rust async/await, DashMap, AWS Lambda, and IntelliJ Rust, and have published 3 open-source Rust crates for backend development.

I am excited to bring my Java domain expertise and Rust performance gains to your team. Thank you for your time and consideration.

Sincerely,
[Your Name]
"#;

    print!("Generated cover letter:
{}", cover_letter);
    print!("Save to file? (y/n): ");
    io::stdout().flush()?;

    let mut input = String::new();
    io::stdin().read_line(&mut input)?;

    if input.trim().to_lowercase() == "y" {
        std::fs::write("cover_letter.txt", cover_letter)?;
        println!("Cover letter saved to cover_letter.txt");
    }

    Ok(())
}

[tasks.lint]
command = "cargo"
args = ["clippy", "--all-targets", "--all-features", "-- -D warnings"]

[tasks.test]
command = "cargo"
args = ["test", "--all-features"]

[tasks.deploy]
dependencies = ["lint", "test"]
command = "cargo"
args = ["build", "--release", "--target x86_64-unknown-linux-musl"]

// Run configuration template (IntelliJ Rust)
Command: cargo
Args: run --bin auth-server
Environment variables: RUST_LOG=info
Working directory: /path/to/rust-project

use criterion::{black_box, criterion_group, criterion_main, Criterion};
use sha2::{Sha256, Digest};

fn hash_password(password: &str) -> String {
    let mut hasher = Sha256::new();
    hasher.update(password.as_bytes());
    hex::encode(hasher.finalize())
}

fn benchmark_hash_password(c: &mut Criterion) {
    c.bench_function("hash_password", |b| {
        b.iter(|| hash_password(black_box("password123")))
    });
}

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

rust-java-migration/
├── java-services/
│   ├── auth-service/          # Java 21 auth service (original)
│   │   ├── pom.xml
│   │   └── src/main/java/com/example/UserAuthService.java
│   └── audit-scripts/         # Java dependency audit tools
│       └── JdepsAudit.java
├── rust-services/
│   ├── auth-service/          # Rust 1.84 auth service (rewritten)
│   │   ├── Cargo.toml
│   │   └── src/main.rs
│   ├── auth-lambda/           # Rust AWS Lambda auth handler
│   │   ├── Cargo.toml
│   │   └── src/main.rs
│   └── benchmarks/            # Criterion benchmarks
│       ├── Cargo.toml
│       └── benches/hash_password.rs
├── concept-mapping/           # Java to Rust reference tools
│   └── src/main.rs
├── job-tools/                 # Cover letter generator, resume tools
│   └── src/main.rs
└── README.md                  # Migration guide and benchmarks