Code Quality and Communication Questions

Skills and practices for producing readable, maintainable, and idiomatic code while clearly communicating intent. Candidates should demonstrate clear naming, logical structure, proper error handling, and writing code that other engineers can easily review and extend. This topic also covers narrating your thought process while coding, explaining trade offs between readability and optimization, identifying next optimization steps, and knowing when to avoid premature optimization. Interviewers will assess both the code you produce and your ability to explain design choices and sequencing of improvements.

MediumTechnical

122 practiced

You're given two implementations of the same feature: one is shorter and faster, the other is more verbose but much easier to understand. How would you decide which version to merge, and what evidence would you ask for before making the call?

EasyTechnical

120 practiced

A junior engineer asks whether they should add a comment to explain a block of code or rewrite the code to make the intent obvious. How would you coach them, and what examples would you give?

MediumTechnical

85 practiced

What does an effective code review culture look like on a healthy team, and how do you make sure feedback stays constructive, specific, and focused on the code rather than the person?

HardTechnical

129 practiced

After a production incident, you discover the root cause was not a logic bug but an ambiguous variable name and an overly dense control flow that misled two reviewers. How would you run the postmortem, and what process changes would you introduce?

MediumTechnical

67 practiced

In Python, implement a function named extract_valid_emails(records) that takes a list of dictionaries and returns a sorted list of email strings where the email contains exactly one @ and both the local part and domain part are non-empty. Handle malformed records without crashing, and narrate your thought process as you code.

Sample Answer

I’ll write this defensively: only accept records that are dictionaries, safely read the email field, validate the format, and keep the result sorted.

python

def extract_valid_emails(records):
    """Return sorted valid emails from a list of dict records."""
    valid_emails = []

    for record in records:
        # Skip malformed items that aren't dictionaries
        if not isinstance(record, dict):
            continue

        email = record.get("email")
        if not isinstance(email, str):
            continue

        # Must contain exactly one @ and both sides non-empty
        if email.count("@") != 1:
            continue

        local_part, domain_part = email.split("@")
        if local_part and domain_part:
            valid_emails.append(email)

    return sorted(valid_emails)

**Thought process**- I avoid crashing on bad input by checking types first.- I treat validation as a small set of explicit rules.- I return a sorted list because the prompt asks for sorted output.

**Complexity**: O(n log n) due to sorting; scanning is O(n).

**Edge cases**: missing `email`, non-string values, multiple `@` symbols, empty local/domain parts, and non-dict records.

Unlock Full Question Bank

Get access to hundreds of Code Quality and Communication interview questions and detailed answers.

Join thousands of developers preparing for their dream job.