Software Lead Engineer - Space Simulation (Space Domain)

Strong, recent hands-on experience in a compiled systems language (C++ preferred) writing numerically intensive code that must be correct first and performant second

Shared-memory parallelism: threading models, race condition analysis, false sharing avoidance, thread-safe logging

Memory layout design for cache-friendly access across large object populations

Integration with third-party C scientific libraries without memory leaks or undefined behaviour

Attitude representation: quaternion algebra, renormalisation, singularity avoidance — able to articulate from first principles why gimbal-lock representations are unacceptable in a simulation context

Adaptive step integration: step acceptance and rejection logic, error estimation, handling of state variables that change continuously during propulsive events

Spacecraft sensor and actuator modelling: understanding of the measurement chain from physical sensor to estimated state, and actuator dynamics including saturation behaviour

Design and implementation of binary scientific data formats for large time-series datasets produced by long-running HPC jobs: incremental write patterns, crash safety, and reading partially written output from a concurrent consumer

On-the-fly computation at query time over large catalogues — understanding the trade-offs between pre-computation and real-time evaluation

Ground truth vs estimated state: designing a system where operators never see true simulation state, only what an estimation chain would produce from simulated sensor measurements

Direct experience writing job scripts for a workload manager (SLURM or equivalent): resource allocation, node selection, job arrays

Interactive vs batch job submission — knowing the operational difference and when each is appropriate

Job lifecycle monitoring: status polling, sentinel-file-based completion detection, epilog handling

Single-node multi-core parallelism within a job; understanding when intra-job distributed parallelism is unnecessary complexity

Shared storage access from multiple compute nodes; filesystem coherency considerations

Deploying scientific software on Linux HPC clusters: build systems, shared library management, packaging for the deployment OS

Native desktop application development (not web-based): signal/slot or equivalent event model, OpenGL integration via a widget, animation timers decoupled from simulation time

Custom OpenGL rendering: vertex array objects, instanced geometry, batched buffer uploads, shader authorship — able to render tens of thousands of objects in a single draw call

3D Earth visualisation: geodetic ellipsoid rendering, instanced marker sprites, trajectory polyline batching, arcball or equivalent camera control

Role-based panel visibility driven by login state within a single application — not multiple executables

Desktop application packaging: producing an installer for analyst workstations with a configurable server address at install time

Build system authorship for compiled code: dependency resolution, compiler flags, packaging for the target deployment OS

Python environment and dependency management: deterministic lockfiles, reproducible environments across nodes

Structured logging strategy: separating per-job logs from per-process service logs, human-readable and machine-parseable outputs, never sharing file handles across process boundaries