What a Senior } should know

Applies algorithmic expertise to compiler development: parsing algorithm optimization (LL/LR/PEG), type inference algorithm design, register allocation algorithms for code generation. Designs incremental compilation algorithms that minimize recompilation scope for large codebases.

Designs async architectures for language tools: parallel compilation strategies, async LSP server architecture, concurrent file watching and incremental compilation. Mentors team on async patterns for compiler performance optimization.

Designs code quality standards for compiler and language tooling codebases: AST manipulation clarity, visitor pattern consistency, parser maintainability. Refactors complex code generation pipelines for testability. Establishes review practices for semantic correctness, performance regression prevention, and cross-platform compatibility.

Selects optimal data structures for compiler internals: rope data structures for editor text buffers, interned string tables for symbol resolution, persistent syntax trees for incremental compilation. Optimizes AST node representations for minimal memory footprint. Designs efficient data structures for type inference engines and semantic analysis passes.

Has deep expertise in design patterns for compilers: designs extensible compiler architectures with visitor and interpreter patterns, implements plugin systems for compiler passes and code generators, optimizes pattern usage for compilation performance. Mentors team on compiler design patterns for language ecosystem tools.

Architects compiler internals using advanced FP: optimization passes as composable pure transformations, type checkers with monadic constraint solvers, and complex language semantics modeled via GADTs. Mentors team on recursion schemes for AST transformations and catamorphisms for code generation.

Designs cross-language generic type system tooling: implements constraint solvers for generic type inference (Hindley-Milner extensions, local type inference), builds incremental type checkers that efficiently handle generic instantiation caching. Architects IDE features for generic code — smart completion with type parameter inference, generic refactoring (extract type parameter, inline type alias), and diagnostic messages that clearly explain constraint violation chains in complex generic contexts.

Designs IR optimization passes using dominance frontiers, control flow graphs, and SSA construction algorithms. Architects incremental re-parsing with graph-diffing for IDE responsiveness. Mentors developers on advanced graph algorithms for type inference, escape analysis, and inter-procedural data flow.

Designs language tooling architectures leveraging immutability for incremental analysis, concurrent processing, and reliable IDE experiences. Implements advanced patterns including Salsa-style incremental computation frameworks with immutable inputs, persistent syntax tree designs for zero-copy editing, and lock-free concurrent analysis on shared immutable snapshots. Optimizes immutable data structures for responsive IDE performance with efficient structural sharing and lazy evaluation.

Designs memory-efficient compiler/LSP architectures: incremental compilation with selective invalidation, persistent data structures for immutable ASTs, and memory-mapped source files. Implements custom allocators for type-checking passes and code generation. Optimizes IDE responsiveness through lazy evaluation and demand-driven computation. Mentors team on memory profiling for language tools.

Has deep expertise in multithreading for compilers: designs parallel compilation architectures for build speed optimization, implements concurrent type checking and code analysis passes, optimizes thread scheduling for incremental compilation. Mentors team on concurrent programming patterns for language tool performance.

Applies OOP/SOLID in compiler architecture: visitor pattern for AST traversal, abstract factory for syntax node creation, strategy pattern for code generation backends. Designs extensible compiler pipelines with clean separation between parsing, semantic analysis, and code generation phases.

Has deep expertise in type system theory and implementation — designs type inference engines, implements constraint-based type solvers, and builds type-aware refactoring tools. Architects gradual typing systems balancing soundness with adoption ergonomics. Mentors team on formal type theory foundations, decidability trade-offs in type checking, and practical type system design patterns.

Designs comprehensive API documentation architecture for language toolchain products. Defines documentation standards for LSP extensions, compiler APIs, and debug adapter interfaces with protocol compliance matrices. Establishes automated documentation generation from language specifications and protocol schema definitions.

Designs API architecture for language services: code analysis API at scale, compilation-as-a-service endpoints, IDE integration APIs with real-time capabilities. Defines API contracts for language tool ecosystem. Mentors team on API design for developer tooling.

Designs CI/CD architecture for language tooling: optimizes multi-platform compiler build pipelines, implements progressive release strategies for language ecosystem packages, architects benchmark regression detection in CI. Mentors team on compiler CI/CD best practices.

Designs integration testing strategy for language toolchain components from lexer through code generation. Implements automated testing across parser, type checker, and IDE integration layers. Optimizes test pyramid balancing grammar unit tests with end-to-end compilation integration validation. Mentors team on testing language server protocol compliance and cross-editor compatibility.

Designs property-based testing strategy for the entire language toolchain. Implements automated verification of compiler correctness, optimizer invariants, and code generation properties. Mentors the team on effective generator design and shrinking.

Designs testing architecture for language tooling platform: conformance test suites for language specification, fuzz testing for parser robustness, and BDD-driven feature acceptance. Implements golden file testing for code generation and formatting. Creates testing infrastructure for cross-platform language tool validation. Mentors team on test-driven compiler/LSP development.

Designs testing strategy for language tooling: test pyramid for lexer/parser/analyzer/codegen stages, conformance test suites for language spec, fuzzing for parser robustness. Optimizes compiler test execution with incremental test selection. Mentors team on snapshot-based testing and regression prevention.

Has deep expertise in applying ChatGPT/Claude for language tool development. Designs AI-assisted workflows for grammar prototyping, type system implementation, and automated test corpus generation. Optimizes prompt engineering for compiler engineering tasks and mentors team on leveraging LLMs for language design exploration and documentation.

Designs GitHub Copilot adoption strategies for language tooling teams: optimizes prompt engineering for compiler and parser code, implements correctness validation for AI-generated AST transformations, evaluates Copilot accuracy for language specification compliance. Mentors team on critical evaluation of AI-assisted compiler code.

Designs code review processes for language tools: compiler correctness review standards, parser robustness review checklists, language spec compliance review gates. Mentors team on reviewing compiler code for correctness and performance.

Designs comprehensive documentation systems for language tools: interactive documentation with embedded code execution, version-aware API references, and migration guides generated from breaking change detection. Implements documentation testing (doctests) as part of CI. Mentors team on documentation architecture.

Designs Git workflows for language tooling teams: implements branching strategies for spec versioning alongside compiler/runtime releases, optimizes monorepo management for language ecosystem packages, automates regression detection through bisect integration in CI. Mentors team on maintaining backward compatibility through careful branch management.

Designs AST frameworks powering IDE features like auto-completion and semantic highlighting. Architects incremental parsing and type-aware transformations. Mentors the team on tree-based program analysis techniques.

Designs code generation pipelines with pluggable backends for multiple target platforms. Architects JIT compilation and incremental code generation strategies. Mentors the team on compiler backend design and optimization trade-offs.

Architects DSL ecosystems with composable grammars, type systems, and compilation targets. Designs language server protocols for DSL IDE support. Mentors the team on language design principles and user experience trade-offs.

Designs interpreter architectures with JIT compilation tiers and adaptive optimization. Architects debugging and profiling infrastructure for interpreted language runtimes. Mentors the team on VM design trade-offs and runtime performance engineering.

Designs language server architecture with workspace-wide analysis, refactoring support, and code actions. Optimizes server performance for large codebases with lazy evaluation and caching strategies.

Designs incremental parsing architectures (tree-sitter style) for real-time editor feedback. Implements grammar composition for embedded languages and optimizes parser performance for large source files.

Designs advanced type system features including dependent types, GADTs, and type-level computation. Architects compiler optimization passes that leverage type information for better code generation. Mentors the team on type theory.

Architects benchmarking infrastructure for language tooling projects with automated regression tracking across releases. Designs representative benchmark corpora covering diverse codebases and compilation scenarios. Implements performance budgets for compiler passes and IDE responsiveness. Mentors team on measurement methodology.

Designs CPU profiling strategies for complex language toolchains including LSP servers, compilers, and debuggers. Builds custom profiling harnesses for measuring instruction-level performance. Mentors the team on interpreting IPC, cache miss, and branch prediction data from hardware counters.

Designs latency-optimized architectures for language tools: demand-driven compilation with minimal recomputation, parallel analysis pipelines with result merging, and predictive prefetching for completion candidates. Implements latency budgets for IDE operations (16ms for keystroke response, 100ms for completion). Creates performance regression detection in CI. Mentors team on latency-aware tool design.

Designs memory profiling infrastructure for language toolchains — custom allocator tracking, compile-time memory regression tests, and automated leak detection in CI. Optimizes memory layout of core compiler data structures (ASTs, symbol tables, type graphs) using profiling data from massif, heaptrack, and custom instrumentation. Mentors the team on memory-efficient IR design and identifies systemic allocation hotspots across multi-pass compilation stages.