Lesson proof
Concept, demo, checklist, lab, and assignment evidence.
Compilers / Interpreters / Virtual Machines / Systems / Runtime and Compiler Engineer
Runtime and Compiler Engineering
Teach how programming languages become running software: lexical analysis, parsing, ASTs, interpreters, compilers, type systems, bytecode, virtual machines, JIT, memory management, garbage collection, linking, debugging, performance, packaging, and runtime operations.
Runtime systems portfolioCompiler fundamentals readinessPerformance and debugging evidence
Start domain mock testPlatform-wide module outputs
Every module now feeds portfolio proof and CV readiness.
Portfolio pack
Requirement, artifact, validation, risk note, and interview story.
CV signal
Role-specific skill statement linked to a score or artifact.
Review queue
Submitted evidence can support dashboard, readiness, and career exports.
Open materials
Runtime and compiler foundationsLesson + portfolio pack + CV evidenceProgramming language execution modelsLesson + portfolio pack + CV evidenceLexical analysis tokens and scanningLesson + portfolio pack + CV evidenceParsing grammars ASTs and syntax errorsLesson + portfolio pack + CV evidenceSemantic analysis symbol tables and scopeLesson + portfolio pack + CV evidenceType systems static dynamic and inferenceLesson + portfolio pack + CV evidenceInterpreters tree-walk and bytecode executionLesson + portfolio pack + CV evidenceIntermediate representations and control flowLesson + portfolio pack + CV evidenceCode generation assembly and machine modelLesson + portfolio pack + CV evidenceVirtual machines bytecode and stack machinesLesson + portfolio pack + CV evidenceJIT compilation optimization and deoptimizationLesson + portfolio pack + CV evidenceMemory management stack heap and garbage collectionLesson + portfolio pack + CV evidenceLinking loading modules and package systemsLesson + portfolio pack + CV evidenceDebugging profiling tracing and observabilityLesson + portfolio pack + CV evidenceSecurity sandboxing and safe runtime designLesson + portfolio pack + CV evidenceRuntime and compiler capstoneLesson + portfolio pack + CV evidence
Certification objective coverage
Every provider-aligned module is connected to a lesson, labs, mock questions, and implementation proof.
This is the track-level audit view for blueprint alignment. Exact exam wording should still be checked against the current official provider guide before public exam-code claims are made.
runtime-compiler-engineering.runtime-and-compiler-foundations.01 / 6% weight
Apply Runtime and compiler foundations decisions to Runtime and Compiler Engineer scenarios
Implementation proof
- Define Runtime and compiler foundations in plain language and explain the provider service family it belongs to.
- Show how Runtime and compiler foundations is implemented through a guided configuration, simulator, command, diagram, notebook, or case study.
- Capture evidence with screenshots, command output, logs, metrics, topology state, policy review, query result, or troubleshooting notes.
- Connect the evidence to a portfolio pack, CV-ready skill statement, and mock-test weak-domain recovery action.
Evidence requirements
- Correct scenario decision in mock exam
- Written explanation of the key requirement or constraint
- Hands-on lab evidence or troubleshooting proof
- Portfolio pack with requirement, artifact, validation, risk note, and interview story
- CV-ready skill statement linked to a score, artifact, or project result
runtime-compiler-engineering.programming-language-execution-models.02 / 6% weight
Apply Programming language execution models decisions to Runtime and Compiler Engineer scenarios
Implementation proof
- Define Programming language execution models in plain language and explain the provider service family it belongs to.
- Show how Programming language execution models is implemented through a guided configuration, simulator, command, diagram, notebook, or case study.
- Capture evidence with screenshots, command output, logs, metrics, topology state, policy review, query result, or troubleshooting notes.
- Connect the evidence to a portfolio pack, CV-ready skill statement, and mock-test weak-domain recovery action.
Evidence requirements
- Correct scenario decision in mock exam
- Written explanation of the key requirement or constraint
- Hands-on lab evidence or troubleshooting proof
- Portfolio pack with requirement, artifact, validation, risk note, and interview story
- CV-ready skill statement linked to a score, artifact, or project result
runtime-compiler-engineering.lexical-analysis-tokens-and-scanning.03 / 6% weight
Apply Lexical analysis tokens and scanning decisions to Runtime and Compiler Engineer scenarios
Implementation proof
- Define Lexical analysis tokens and scanning in plain language and explain the provider service family it belongs to.
- Show how Lexical analysis tokens and scanning is implemented through a guided configuration, simulator, command, diagram, notebook, or case study.
- Capture evidence with screenshots, command output, logs, metrics, topology state, policy review, query result, or troubleshooting notes.
- Connect the evidence to a portfolio pack, CV-ready skill statement, and mock-test weak-domain recovery action.
Evidence requirements
- Correct scenario decision in mock exam
- Written explanation of the key requirement or constraint
- Hands-on lab evidence or troubleshooting proof
- Portfolio pack with requirement, artifact, validation, risk note, and interview story
- CV-ready skill statement linked to a score, artifact, or project result
runtime-compiler-engineering.parsing-grammars-asts-and-syntax-errors.04 / 6% weight
Apply Parsing grammars ASTs and syntax errors decisions to Runtime and Compiler Engineer scenarios
Implementation proof
- Define Parsing grammars ASTs and syntax errors in plain language and explain the provider service family it belongs to.
- Show how Parsing grammars ASTs and syntax errors is implemented through a guided configuration, simulator, command, diagram, notebook, or case study.
- Capture evidence with screenshots, command output, logs, metrics, topology state, policy review, query result, or troubleshooting notes.
- Connect the evidence to a portfolio pack, CV-ready skill statement, and mock-test weak-domain recovery action.
Evidence requirements
- Correct scenario decision in mock exam
- Written explanation of the key requirement or constraint
- Hands-on lab evidence or troubleshooting proof
- Portfolio pack with requirement, artifact, validation, risk note, and interview story
- CV-ready skill statement linked to a score, artifact, or project result
runtime-compiler-engineering.semantic-analysis-symbol-tables-and-scope.05 / 6% weight
Apply Semantic analysis symbol tables and scope decisions to Runtime and Compiler Engineer scenarios
Implementation proof
- Define Semantic analysis symbol tables and scope in plain language and explain the provider service family it belongs to.
- Show how Semantic analysis symbol tables and scope is implemented through a guided configuration, simulator, command, diagram, notebook, or case study.
- Capture evidence with screenshots, command output, logs, metrics, topology state, policy review, query result, or troubleshooting notes.
- Connect the evidence to a portfolio pack, CV-ready skill statement, and mock-test weak-domain recovery action.
Evidence requirements
- Correct scenario decision in mock exam
- Written explanation of the key requirement or constraint
- Hands-on lab evidence or troubleshooting proof
- Portfolio pack with requirement, artifact, validation, risk note, and interview story
- CV-ready skill statement linked to a score, artifact, or project result
runtime-compiler-engineering.type-systems-static-dynamic-and-inference.06 / 6% weight
Apply Type systems static dynamic and inference decisions to Runtime and Compiler Engineer scenarios
Implementation proof
- Define Type systems static dynamic and inference in plain language and explain the provider service family it belongs to.
- Show how Type systems static dynamic and inference is implemented through a guided configuration, simulator, command, diagram, notebook, or case study.
- Capture evidence with screenshots, command output, logs, metrics, topology state, policy review, query result, or troubleshooting notes.
- Connect the evidence to a portfolio pack, CV-ready skill statement, and mock-test weak-domain recovery action.
Evidence requirements
- Correct scenario decision in mock exam
- Written explanation of the key requirement or constraint
- Hands-on lab evidence or troubleshooting proof
- Portfolio pack with requirement, artifact, validation, risk note, and interview story
- CV-ready skill statement linked to a score, artifact, or project result
runtime-compiler-engineering.interpreters-tree-walk-and-bytecode-execution.07 / 6% weight
Apply Interpreters tree-walk and bytecode execution decisions to Runtime and Compiler Engineer scenarios
Implementation proof
- Define Interpreters tree-walk and bytecode execution in plain language and explain the provider service family it belongs to.
- Show how Interpreters tree-walk and bytecode execution is implemented through a guided configuration, simulator, command, diagram, notebook, or case study.
- Capture evidence with screenshots, command output, logs, metrics, topology state, policy review, query result, or troubleshooting notes.
- Connect the evidence to a portfolio pack, CV-ready skill statement, and mock-test weak-domain recovery action.
Evidence requirements
- Correct scenario decision in mock exam
- Written explanation of the key requirement or constraint
- Hands-on lab evidence or troubleshooting proof
- Portfolio pack with requirement, artifact, validation, risk note, and interview story
- CV-ready skill statement linked to a score, artifact, or project result
runtime-compiler-engineering.intermediate-representations-and-control-flow.08 / 6% weight
Apply Intermediate representations and control flow decisions to Runtime and Compiler Engineer scenarios
Implementation proof
- Define Intermediate representations and control flow in plain language and explain the provider service family it belongs to.
- Show how Intermediate representations and control flow is implemented through a guided configuration, simulator, command, diagram, notebook, or case study.
- Capture evidence with screenshots, command output, logs, metrics, topology state, policy review, query result, or troubleshooting notes.
- Connect the evidence to a portfolio pack, CV-ready skill statement, and mock-test weak-domain recovery action.
Evidence requirements
- Correct scenario decision in mock exam
- Written explanation of the key requirement or constraint
- Hands-on lab evidence or troubleshooting proof
- Portfolio pack with requirement, artifact, validation, risk note, and interview story
- CV-ready skill statement linked to a score, artifact, or project result
runtime-compiler-engineering.code-generation-assembly-and-machine-model.09 / 6% weight
Apply Code generation assembly and machine model decisions to Runtime and Compiler Engineer scenarios
Implementation proof
- Define Code generation assembly and machine model in plain language and explain the provider service family it belongs to.
- Show how Code generation assembly and machine model is implemented through a guided configuration, simulator, command, diagram, notebook, or case study.
- Capture evidence with screenshots, command output, logs, metrics, topology state, policy review, query result, or troubleshooting notes.
- Connect the evidence to a portfolio pack, CV-ready skill statement, and mock-test weak-domain recovery action.
Evidence requirements
- Correct scenario decision in mock exam
- Written explanation of the key requirement or constraint
- Hands-on lab evidence or troubleshooting proof
- Portfolio pack with requirement, artifact, validation, risk note, and interview story
- CV-ready skill statement linked to a score, artifact, or project result
runtime-compiler-engineering.virtual-machines-bytecode-and-stack-machines.10 / 6% weight
Apply Virtual machines bytecode and stack machines decisions to Runtime and Compiler Engineer scenarios
Implementation proof
- Define Virtual machines bytecode and stack machines in plain language and explain the provider service family it belongs to.
- Show how Virtual machines bytecode and stack machines is implemented through a guided configuration, simulator, command, diagram, notebook, or case study.
- Capture evidence with screenshots, command output, logs, metrics, topology state, policy review, query result, or troubleshooting notes.
- Connect the evidence to a portfolio pack, CV-ready skill statement, and mock-test weak-domain recovery action.
Evidence requirements
- Correct scenario decision in mock exam
- Written explanation of the key requirement or constraint
- Hands-on lab evidence or troubleshooting proof
- Portfolio pack with requirement, artifact, validation, risk note, and interview story
- CV-ready skill statement linked to a score, artifact, or project result
runtime-compiler-engineering.jit-compilation-optimization-and-deoptimization.11 / 6% weight
Apply JIT compilation optimization and deoptimization decisions to Runtime and Compiler Engineer scenarios
Implementation proof
- Define JIT compilation optimization and deoptimization in plain language and explain the provider service family it belongs to.
- Show how JIT compilation optimization and deoptimization is implemented through a guided configuration, simulator, command, diagram, notebook, or case study.
- Capture evidence with screenshots, command output, logs, metrics, topology state, policy review, query result, or troubleshooting notes.
- Connect the evidence to a portfolio pack, CV-ready skill statement, and mock-test weak-domain recovery action.
Evidence requirements
- Correct scenario decision in mock exam
- Written explanation of the key requirement or constraint
- Hands-on lab evidence or troubleshooting proof
- Portfolio pack with requirement, artifact, validation, risk note, and interview story
- CV-ready skill statement linked to a score, artifact, or project result
runtime-compiler-engineering.memory-management-stack-heap-and-garbage-collection.12 / 6% weight
Apply Memory management stack heap and garbage collection decisions to Runtime and Compiler Engineer scenarios
Implementation proof
- Define Memory management stack heap and garbage collection in plain language and explain the provider service family it belongs to.
- Show how Memory management stack heap and garbage collection is implemented through a guided configuration, simulator, command, diagram, notebook, or case study.
- Capture evidence with screenshots, command output, logs, metrics, topology state, policy review, query result, or troubleshooting notes.
- Connect the evidence to a portfolio pack, CV-ready skill statement, and mock-test weak-domain recovery action.
Evidence requirements
- Correct scenario decision in mock exam
- Written explanation of the key requirement or constraint
- Hands-on lab evidence or troubleshooting proof
- Portfolio pack with requirement, artifact, validation, risk note, and interview story
- CV-ready skill statement linked to a score, artifact, or project result
runtime-compiler-engineering.linking-loading-modules-and-package-systems.13 / 6% weight
Apply Linking loading modules and package systems decisions to Runtime and Compiler Engineer scenarios
Implementation proof
- Define Linking loading modules and package systems in plain language and explain the provider service family it belongs to.
- Show how Linking loading modules and package systems is implemented through a guided configuration, simulator, command, diagram, notebook, or case study.
- Capture evidence with screenshots, command output, logs, metrics, topology state, policy review, query result, or troubleshooting notes.
- Connect the evidence to a portfolio pack, CV-ready skill statement, and mock-test weak-domain recovery action.
Evidence requirements
- Correct scenario decision in mock exam
- Written explanation of the key requirement or constraint
- Hands-on lab evidence or troubleshooting proof
- Portfolio pack with requirement, artifact, validation, risk note, and interview story
- CV-ready skill statement linked to a score, artifact, or project result
runtime-compiler-engineering.debugging-profiling-tracing-and-observability.14 / 6% weight
Apply Debugging profiling tracing and observability decisions to Runtime and Compiler Engineer scenarios
Implementation proof
- Define Debugging profiling tracing and observability in plain language and explain the provider service family it belongs to.
- Show how Debugging profiling tracing and observability is implemented through a guided configuration, simulator, command, diagram, notebook, or case study.
- Capture evidence with screenshots, command output, logs, metrics, topology state, policy review, query result, or troubleshooting notes.
- Connect the evidence to a portfolio pack, CV-ready skill statement, and mock-test weak-domain recovery action.
Evidence requirements
- Correct scenario decision in mock exam
- Written explanation of the key requirement or constraint
- Hands-on lab evidence or troubleshooting proof
- Portfolio pack with requirement, artifact, validation, risk note, and interview story
- CV-ready skill statement linked to a score, artifact, or project result
runtime-compiler-engineering.security-sandboxing-and-safe-runtime-design.15 / 6% weight
Apply Security sandboxing and safe runtime design decisions to Runtime and Compiler Engineer scenarios
Implementation proof
- Define Security sandboxing and safe runtime design in plain language and explain the provider service family it belongs to.
- Show how Security sandboxing and safe runtime design is implemented through a guided configuration, simulator, command, diagram, notebook, or case study.
- Capture evidence with screenshots, command output, logs, metrics, topology state, policy review, query result, or troubleshooting notes.
- Connect the evidence to a portfolio pack, CV-ready skill statement, and mock-test weak-domain recovery action.
Evidence requirements
- Correct scenario decision in mock exam
- Written explanation of the key requirement or constraint
- Hands-on lab evidence or troubleshooting proof
- Portfolio pack with requirement, artifact, validation, risk note, and interview story
- CV-ready skill statement linked to a score, artifact, or project result
runtime-compiler-engineering.runtime-and-compiler-capstone.16 / 10% weight
Apply Runtime and compiler capstone decisions to Runtime and Compiler Engineer scenarios
Implementation proof
- Define Runtime and compiler capstone in plain language and explain the provider service family it belongs to.
- Show how Runtime and compiler capstone is implemented through a guided configuration, simulator, command, diagram, notebook, or case study.
- Capture evidence with screenshots, command output, logs, metrics, topology state, policy review, query result, or troubleshooting notes.
- Connect the evidence to a portfolio pack, CV-ready skill statement, and mock-test weak-domain recovery action.
Evidence requirements
- Correct scenario decision in mock exam
- Written explanation of the key requirement or constraint
- Hands-on lab evidence or troubleshooting proof
- Portfolio pack with requirement, artifact, validation, risk note, and interview story
- CV-ready skill statement linked to a score, artifact, or project result
Test readiness
Mock test by domain
Practice every domain in this track with exam-style questions, answer keys, and explanations.
Open mock testMost in-demand certification materials
High-value certificates connected to this track.
Computer science / language tooling
Compiler and Interpreter Engineering readiness
Needs reviewLast verified: Not verifiedNext review: Provider source review required
Developers who want to understand scanners, parsers, ASTs, interpreters, semantic analysis, bytecode, and language implementation fundamentals.
Compiler and Interpreter Engineering readiness is mapped to platform lessons and labs, but still needs a dated official-source review.
- Compiler pipeline map from source code to tokens, AST, semantic checks, IR, execution, and diagnostics
- Tokenizer, parser, AST, interpreter, and runtime error lab checklist
- Language implementation scenario questions with debugging and design tradeoffs
LLVM ecosystem
LLVM and native code generation readiness
Needs reviewLast verified: Not verifiedNext review: Provider source review required
Systems learners moving from interpreters into intermediate representation, optimization passes, native code generation, and toolchains.
LLVM and native code generation readiness is mapped to platform lessons and labs, but still needs a dated official-source review.
- IR, basic block, control flow graph, SSA, optimization pass, and backend vocabulary map
- Native code generation and assembly inspection practice
- Optimization and correctness review workbook
Rust ecosystem
Rust systems programming readiness
Needs reviewLast verified: Not verifiedNext review: Provider source review required
Runtime, compiler, systems, WebAssembly, infrastructure, and performance-focused developers.
Rust systems programming readiness is mapped to platform lessons and labs, but still needs a dated official-source review.
- Ownership, borrowing, lifetimes, traits, Result, Option, and unsafe boundary checklist
- Memory safety and runtime systems practice tasks
- Package, module, testing, benchmarking, and CLI tooling notes
W3C / WASM ecosystem
WebAssembly runtime readiness
Needs reviewLast verified: Not verifiedNext review: Provider source review required
Developers building portable, sandboxed, high-performance runtime modules across browsers, edge, plugins, and server workloads.
WebAssembly runtime readiness is mapped to platform lessons and labs, but still needs a dated official-source review.
- WASM module, memory, imports, exports, host function, sandbox, and runtime vocabulary map
- Bytecode and portable execution scenario drills
- Security and host-boundary review checklist
Java / JVM ecosystem
Java JVM and managed runtime readiness
Needs reviewLast verified: Not verifiedNext review: Provider source review required
Backend and platform engineers who need bytecode, class loading, garbage collection, profiling, JIT, and managed runtime behavior.
Java JVM and managed runtime readiness is mapped to platform lessons and labs, but still needs a dated official-source review.
- JVM bytecode, class loading, heap, stack, GC, JIT, warmup, and profiling concept map
- Managed runtime troubleshooting and performance tuning drills
- Runtime metrics, logs, heap, thread, and latency evidence checklist
Systems performance practice
Performance profiling and observability readiness
Needs reviewLast verified: Not verifiedNext review: Provider source review required
Developers and platform engineers diagnosing CPU, memory, latency, allocation, startup, throughput, and runtime reliability issues.
Performance profiling and observability readiness is mapped to platform lessons and labs, but still needs a dated official-source review.
- Profiling, tracing, benchmark, flame graph, allocation, and latency checklist
- Runtime bottleneck diagnosis scenario pack
- Performance evidence report template with baseline, change, result, and tradeoff
Certification provider connections
Connect this learning path to the official exam provider.
Certification provider
Compiler and Interpreter Engineering readiness
Confirm the official provider, exam code, delivery rules, ID policy, and reschedule window before booking.
Booking partner: Provider exam partner
- Create or confirm the Provider learner account.
- Review the official exam guide, ID policy, delivery options, and reschedule rules.
- Add target exam date, booking status, renewal date, and certificate proof to the learner record.
Certification provider
LLVM and native code generation readiness
Confirm the official provider, exam code, delivery rules, ID policy, and reschedule window before booking.
Booking partner: Provider exam partner
- Create or confirm the Provider learner account.
- Review the official exam guide, ID policy, delivery options, and reschedule rules.
- Add target exam date, booking status, renewal date, and certificate proof to the learner record.
Certification provider
Rust systems programming readiness
Confirm the official provider, exam code, delivery rules, ID policy, and reschedule window before booking.
Booking partner: Provider exam partner
- Create or confirm the Provider learner account.
- Review the official exam guide, ID policy, delivery options, and reschedule rules.
- Add target exam date, booking status, renewal date, and certificate proof to the learner record.
Certification provider
WebAssembly runtime readiness
Confirm the official provider, exam code, delivery rules, ID policy, and reschedule window before booking.
Booking partner: Provider exam partner
- Create or confirm the Provider learner account.
- Review the official exam guide, ID policy, delivery options, and reschedule rules.
- Add target exam date, booking status, renewal date, and certificate proof to the learner record.
Certification provider
Java JVM and managed runtime readiness
Confirm the official provider, exam code, delivery rules, ID policy, and reschedule window before booking.
Booking partner: Provider exam partner
- Create or confirm the Provider learner account.
- Review the official exam guide, ID policy, delivery options, and reschedule rules.
- Add target exam date, booking status, renewal date, and certificate proof to the learner record.
Certification provider
Performance profiling and observability readiness
Confirm the official provider, exam code, delivery rules, ID policy, and reschedule window before booking.
Booking partner: Provider exam partner
- Create or confirm the Provider learner account.
- Review the official exam guide, ID policy, delivery options, and reschedule rules.
- Add target exam date, booking status, renewal date, and certificate proof to the learner record.
01 Match
Map each Daskerel track to the official provider, exam code, registration page, and verification route.
02 Prepare
Use provider objectives with Daskerel lessons, mock exams, labs, and evidence packs before booking.
03 Book
Send learners to the official scheduling partner while keeping target dates and next actions in the dashboard.
04 Verify
Capture certificate URL, badge, expiry, renewal plan, and portfolio proof after the learner passes.
Study plan
Start with how source code moves through scanner, parser, AST, semantic analysis, runtime model, execution, and observable behavior.
Build small interpreters and bytecode machines before studying advanced optimization, JIT, garbage collection, and native code generation.
Practise debugging, profiling, memory reasoning, sandboxing, packaging, and performance evidence so learners understand real production runtimes.
Hands-on labs
Write a tiny language specification with variables, expressions, functions, conditionals, errors, and expected runtime behavior.
Build a tokenizer and parser that produce an AST and helpful syntax errors for a small expression language.
Create a tree-walk interpreter with symbol tables, scope rules, values, control flow, and runtime error handling.
Design a bytecode format and stack-based virtual machine with instructions, frames, constants, and execution tracing.
Add profiling, memory notes, simple optimization, package/module loading, and sandbox restrictions to the runtime.
Package a compiler/runtime portfolio with language guide, architecture diagram, tests, benchmarks, traces, and debugging evidence.
Track learning assets
Templates and revision tools for this path.
Exam blueprint checklistRuntime and Compiler Engineering
Weekly study plannerRuntime and Compiler Engineering
Command and service cheat sheetRuntime and Compiler Engineering
Architecture pattern cardsRuntime and Compiler Engineering
Flashcard revision setRuntime and Compiler Engineering
Mock exam review sheetRuntime and Compiler Engineering
Lab evidence templateRuntime and Compiler Engineering
Interview story builderRuntime and Compiler Engineering
Portfolio project rubricRuntime and Compiler Engineering
Final readiness checklistRuntime and Compiler Engineering
Practice questions
What is the first major step in turning source code into executable behavior?
The source is scanned into tokens, then parsed into a syntax structure such as an AST before semantic checks and execution or compilation.
Why do runtimes need observability and debugging support?
Runtime behavior can fail through syntax, type, memory, performance, concurrency, or environment issues, so traces, profiles, stack frames, and clear errors help engineers diagnose what happened.
What evidence makes a compiler or runtime capstone credible?
A language guide, tokenizer/parser tests, AST examples, interpreter or VM implementation, runtime error examples, benchmark notes, traces, security constraints, and design tradeoff explanation.