Ixana·Software Engineer·Technical Phone Screen·Intermediate

IntermediatePrefer not to say

May 2026

Summary

Got a coding problem at Ixana for a Software Engineer role that was basically a scheduling/execution engine for register operations parsed from a file. Two levels of complexity, the second adding intra-batch dependency tracking. Felt like a systems-adjacent design problem more than a pure algorithms question, which I wasn't fully expecting.

Questions Asked (2)

Given a file describing batches of register read/write operations, implement a function that parses the file, computes a valid logical-time schedule respecting timing constraints (1ms minimum gap between ops, 10ms read-after-write hazard on the same register, strict batch ordering), and executes the operations via provided read_reg and write_reg primitives.

Algorithms & Data StructuresSystem DesignTechnical Trade-offs

Author's notes

This took me a while to even fully parse the problem statement, no pun intended.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the file format and constraints, then outline a parser that builds a dependency graph of operations. Use a greedy scheduler that assigns each operation the earliest valid logical time, and finally execute operations in order while tracking register states.

Pro tip: Mention that you would validate the schedule with a simulation before executing, and discuss how to handle edge cases like missing registers or circular dependencies.

1. Clarify Requirements and File Format

Ask questions to confirm the file structure, operation types, and exact timing constraints. Ensure you understand batch ordering and hazard rules.

2. Design Parser and Data Model

Outline a parser that reads the file into a list of batches, each containing operations with register, type, and any metadata. Represent operations as objects with dependencies.

3. Build Dependency Graph and Schedule

Create a directed graph where edges represent timing constraints (batch order, 1ms gap, 10ms RAW hazard). Use topological sort or greedy scheduling to assign logical times.

4. Execute Operations

Iterate through scheduled operations in time order, calling read_reg or write_reg primitives. Maintain a register state map to enforce hazards.

5. Validate and Test

Simulate the schedule to check constraints, and test with edge cases like empty batches, conflicting operations, and large files.

Key Points to Mention

Parsing strategy: line-by-line or token-based, handling comments and whitespace.
Data structures: use a graph or priority queue for scheduling.
Timing constraints: 1ms minimum gap, 10ms RAW hazard, strict batch ordering.
Algorithm choice: greedy earliest-start vs. topological sort with time assignment.
Execution: call primitives in order, track register states to avoid hazards.
Edge cases: missing registers, circular dependencies, and performance for large files.

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

Extend the solution to handle intra-batch dependencies: some read operations reference another operation line within the same batch (by 1-based line number) and must be scheduled after that referenced operation completes. How do you modify your scheduling logic?

Algorithms & Data StructuresTechnical Trade-offsSystem Design

Author's notes

Level 2 was where I kind of fumbled.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Model the batch as a directed acyclic graph (DAG) where each operation is a node and intra-batch dependencies are edges. Then perform a topological sort to determine a valid execution order, ensuring that referenced operations complete before dependent reads. Discuss how to detect cycles and handle scheduling constraints.

Pro tip: Mention that you would validate the DAG for cycles and provide a clear error message indicating the line numbers involved, as this is crucial for debugging user-defined batches. Also, consider whether dependencies can be resolved at compile time or runtime, and how that impacts performance.

1. Parse and represent dependencies

Extract each operation and its intra-batch dependencies from the batch definition, building a graph where nodes are operations and directed edges represent 'must complete before' relationships.

2. Detect cycles and validate

Check for cycles in the dependency graph using DFS or Kahn's algorithm; if a cycle exists, report an error with the involved line numbers to prevent infinite waits.

3. Compute topological order

Apply a topological sort to produce a linear execution order that respects all dependencies, ensuring referenced operations are scheduled before their dependents.

4. Integrate with existing scheduler

Adapt the scheduler to follow the topological order, possibly by assigning priorities or using a ready queue that only releases operations once their dependencies are satisfied.

5. Handle edge cases and optimize

Consider multiple dependencies, parallel execution opportunities, and whether to resolve dependencies statically or dynamically; discuss trade-offs between precomputed order and on-the-fly scheduling.

Key Points to Mention

Directed acyclic graph (DAG) representation of operations and dependencies
Topological sorting algorithms (Kahn's or DFS-based) for scheduling order
Cycle detection and error reporting with line numbers
Impact on concurrency and potential for parallel execution of independent operations
Trade-offs between static scheduling (precomputed order) and dynamic scheduling (runtime dependency resolution)
Integration with existing batch processing system, including error handling and performance considerations

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.