Progress Careers

Rust Platform & Build Integration

• Integrate Rust (Cargo-based workflows) into the existing CMK (custom Make) build system so Rust shared libraries (.so/.dll) compile, link, and ship alongside 200+ C subsystems across Linux x86_64 and Windows 64-bit.
• Define and standardize Rust ↔ C FFI architecture, including: 
  • Extern "C" boundary design
  • Auto-generated C headers (via cbindgen)
  • Error-handling conventions
  • Memory ownership and lifetime rules
  • Establish Rust as a first-class, supportable language within the core database engine.

Core Systems Libraries

• Design and deliver production-grade Rust shared libraries that replace legacy C implementations, including: 
  • Compression: A Rust-based zstd-backed compression library replacing legacy RDC with drop-in C APIs.
  • JSON Parsing: A memory-safe, multi-threaded Rust JSON parser using serde_json to eliminate known leak and corruption vectors from legacy YAJL-based components.
  • Avro Serialization: A foundational Avro encode/decode layer supporting OpenEdge ↔ Apache Avro type mappings for Apache Iceberg integration.
• Own benchmarking, validation, and parity testing to ensure Rust replacements meet or exceed legacy performance and stability.

Platform & Architecture Leadership

• Architect and lead a Rust-based platform systems layer replacing System V IPC with modern, cross-platform primitives (mmap, POSIX shared memory, futex-style synchronization).
• Enable: 
  • macOS developer builds
  • ARM / Graviton production deployments with significant cost-efficiency gains
• Design NUMA-aware memory allocation strategies for multi-socket, high-throughput production servers using hwloc.
• Guide Tier-3 Rust crates covering cloud file I/O, Iceberg table operations, and engine integration bridges.

• Architect an async gRPC server using tonic, tower, and tokio modernize the PASOE data path and replace Tomcat/HTTP-based flows.
• Design middleware layers for authentication (JWT), observability, and performance isolation with a focus on multi x throughput improvements.

• Act as the Rust code owner across the organization: 
  • Review all Rust PRs
  • Enforce idiomatic Rust, safe unsafe usage, and consistent FFI patterns
• Mentor senior C/C++ engineers transitioning into Rust through: 
  • Pair programming
  • Structured code reviews
  • Hands-on module translation exercises

• Lead the Rust Guild, hosting regular technical sessions covering: 
  • FFI design patterns
  • Async Rust
  • PR walkthroughs and architectural deep dives
• Communicate architectural decisions, trade-offs, and migration strategy clearly to senior leadership and cross-functional stakeholders.
• Partner with management on: 
  • Rust adoption standards
  • Long-term platform strategy
  • Hiring plans and senior Rust capability expansion

• Overall 10+years of Software Engineering Experience with, Must have 5+ years of production Rust in systems-level software — database engines, OS components, embedded systems, network infrastructure, or similar.
• Strong C/C++ background — ability to read, understand, and interface with 10,000+ files of C code daily; you need to think fluently in both languages.
• FFI expertise — production experience with Rust ↔ C interop: extern "C", cbindgen/bindgen, unsafe boundary design, and memory-ownership protocols across language boundaries.
• Shipped shared libraries — experience building .so/.dll Rust libraries consumed by C/C++ callers in production environments.
• Build system integration — experience integrating Cargo with non-Cargo build systems (Make, CMake, Bazel, or custom frameworks).
• Multi-platform development — Linux x86_64 and Windows 64-bit at minimum.
• Experience implementing software using OS fundamentals: file-system and storage management, memory management, virtual memory, process synchronization, and multithreading.
• Strong problem analysis and solving skills; works independently and meets tight deadlines.
• Excellent verbal and written communication skills in English.
• Mentorship / tech-lead experience — you will be training a team, not just writing code.
• A degree in Computer Science or equivalent foundational experience covering data structures, algorithms, operating systems, and database fundamentals.

• Database internals — shared memory, buffer pools, WAL, concurrency control, storage engines.
• gRPC / tonic — production experience building async gRPC services in Rust with tower middleware, prost code generation, and tonic-web for browser compatibility.
• Apache Arrow / Parquet / Iceberg / Avro ecosystem experience.
• NUMA-aware programming — hwloc, mbind(), set_mempolicy(), per-node allocation strategies.
• Memory allocator design — arena/region allocators, custom allocator traits in Rust, jemalloc/mimalloc integration.
• io_uring / async I/O — experience with modern Linux I/O or Rust tokio runtime for systems work.
• macOS and ARM/Graviton platform experience.
• Familiarity with AI-assisted development tools (GitHub Copilot, Claude) for code translation and pair programming workflows.