About the Position

We are looking for an aspiring Rust Developer who wants to gain hands-on experience developing backend components for scalable web applications. You will collaborate with experienced professionals and fellow interns, working on real projects that challenge and enhance your technical skills.

For details about how our internship works, check out our Internship Overview.
Learn more about our team at https://foreachpartners.com/.

What You Will Do

  • Develop server-side logic for web applications using Rust.
  • Write clean, maintainable, and efficient code that integrates with other system components.
  • Collaborate with developers, discussing solutions and ensuring alignment with project requirements.
  • Work with databases, API integrations, and other backend tools.
  • Learn and apply best practices in modern backend development.

What We’re Looking For

  • Core Knowledge:
    • Basic understanding of Rust (pet project experience is sufficient).
    • Theoretical knowledge of backend development concepts.
  • Eagerness to Learn:
    • Willingness to study modern tools and technologies independently.
  • Additional Skills (Nice-to-Have):
    • Familiarity with SQL, Linux CLI, Docker, and Git.
    • Understanding of HTML/CSS fundamentals (including LESS/SASS).
    • Experience using VS Code or other IDEs/editors.
  • Foundational CS Literacy:
    • Basic knowledge of:
      • Databases (queries, indexing),
      • Networking (HTTP, TCP/IP),
      • Web technology stacks,
      • Operating systems (Linux family).

Why Apply?

  • **Real-World Projects:**Work on practical tasks that expand your experience beyond tutorials.
  • **Skill Development:**Sharpen your backend development skills and learn about systems architecture and optimization.
  • Career Growth:
    Outstanding candidates will have the opportunity to continue on commercial terms.

Next Steps: Test Tasks

To apply, complete the following tasks that demonstrate your understanding of Rust, problem-solving ability, and attention to code quality.

Task 1: Implement the getScore Function

Objective:
Write a function getScore(game_stamps, offset) that returns the score at a specific moment (offset). Review the provided code, understand its structure, and ensure your implementation fits seamlessly with the style.

Code:

use rand::Rng;

const TIMESTAMPS_COUNT: usize = 50000;

const PROBABILITY_SCORE_CHANGED: f64 = 0.0001;

const PROBABILITY_HOME_SCORE: f64 = 0.45;

const OFFSET_MAX_STEP: i32 = 3;

const INITIAL_STAMP: Stamp = Stamp {
    offset: 0,
    score: Score { home: 0, away: 0 },
};

#[derive(Debug, Clone, Copy)]
struct Score {
    home: i32,
    away: i32,
}

#[derive(Debug, Clone, Copy)]
struct Stamp {
    offset: i32,
    score: Score,
}

fn generate_stamp(previous_value: Stamp) -> Stamp {
    let score_changed: bool = rand::thread_rng().gen_bool(PROBABILITY_SCORE_CHANGED);
    let home_score_change: bool = rand::thread_rng().gen_bool(PROBABILITY_HOME_SCORE);
    let offset_change: i32 = rand::thread_rng().gen_range(1..=OFFSET_MAX_STEP);

    Stamp {
        offset: previous_value.offset + offset_change,
        score: Score {
            home: previous_value.score.home + if score_changed && home_score_change { 1 } else { 0 },
            away: previous_value.score.away + if score_changed && !home_score_change { 1 } else { 0 },
        },
    }
}

fn generate_game() -> Vec<Stamp> {
    let mut stamps = vec![INITIAL_STAMP];
    let mut current_stamp = INITIAL_STAMP;

    for _ in 0..TIMESTAMPS_COUNT {
        current_stamp = generate_stamp(current_stamp);
        stamps.push(current_stamp);
    }

    stamps
}

fn get_score(game_stamps: &[Stamp], offset: i32) -> (i32, i32) {
    // Implement the function here
}

Deliverables:

  • Provide a link to a gist with your getScore implementation.

Task 2: Write Tests for getScore

Objective:
Write unit tests to verify all edge cases for the getScore function. Follow Rust’s best practices for testing.

Reference: How to Write Tests

Deliverables:

  • Provide a link to a gist with your unit tests.

Task 3: Develop a Rust Hash Finder Application

Objective:

Develop a Rust console application that calculates SHA-256 hashes for consecutive integers, starting from 1. The program must print the hash and the number if the hash ends with N zeros.

Requirements:

Accept N (number of zeros) and F (number of results) as input parameters.
Utilize concurrency/parallelism for optimal performance.
Output hash-number pairs as soon as they are found.

Example Usage:

$ ./hash_finder -N 3 -F 6
4163, "95d4362bd3cd4315d0bbe38dfa5d7fb8f0aed5f1a31d98d510907279194e3000"
11848, "cb58074fd7620cd0ff471922fd9df8812f29f302904b15e389fc14570a66f000"

Deliverables:

  • A link to a public GitHub repository with the full source code and Cargo.toml.
  • Documentation on how to build and run the program.

We look forward to seeing your work and potentially welcoming you to our team!