MR Mikhail RazakovEngineering portfolio

Professional profile / 03 — 03

Mikhail RazakovSOFTWARE ENGINEER · COMPILERS, RUNTIME & PERFORMANCE

I build compiler/runtime components in C#/.NET and C++/LLVM, from optimization-legality checks to generated-code validation. At ISP RAS I work on C# symbolic analysis in SharpChecker; at MCST I worked on LLVM/LICM. I keep correctness evidence and performance measurements separate for experimental optimizations.

Editable formats DOCX Markdown
01 / 04

Experience & practice

Commercial work, research and independent projects are presented separately, without inflating tenure.

Oct 2026 — present

ISP RAS · SharpChecker

Symbolic computation and structured C# code/declaration metadata for static analysis and AI-assisted defect recognition.

Jul — Aug 2026

MCST · compiler engineering internship

C++23/LLVM 22: experimental LICM with conservative legality checks; Python differential checks of before/after behavior.

approx. 1 year total

Commercial development · C#/.NET & adjacent technologies

Application and backend work with C#/.NET, Unity, ASP.NET Core, SQL/PostgreSQL, file I/O and servers. Duration is candidate-reported.

02 / 04

Engineering work

Real constraints, engineering choices and verifiable outcomes.

04
01 / 04

.NET · modular language/toolchain infrastructure · runtime architecture

UniversalToolchain · compiler/runtime infrastructure

Module contracts and dependencies are checked in LanguagePlan before execution. Separate interpreter/CIL backends allow result comparisons for the same language, with dedicated parity scenarios.

Problem

Frontend, semantic components, IR/optimization passes, and execution backends should evolve independently while composing into one deterministic toolchain without hidden registration-order dependencies.

Approach

Typed contracts/capabilities, dependency/conflict resolution, deterministic contribution ordering, and typed artifact routes are resolved into one LanguagePlan before runtime materialization.

Outcome & limits

Implemented an end-to-end pipeline with frontend, IR, optimization passes, interpreter, and a CIL backend; current exact test manifest: 1,324/1,324.

02 / 04

C++23 · LLVM 22 · interprocedural analysis · optimization

LLVM Global IV / LICM · optimization legality

Interprocedural effect analysis is separated from PromotionLegality and the IR transformation. Volatile/atomic accesses, unknown calls and unsupported CFG conservatively reject optimization; negative regression cases cover unsafe paths.

Problem

The pass must recognize affine evolution of global IVs across calls and transform IR only when correctness conditions are established.

Approach

APInt affine b + k·x evolution, transitive function/module effects, loop/dominator/must-execute reasoning, and a separate conservative legality phase that rejects unsupported CFG/calls.

Outcome & limits

A conservative LLVM 22 prototype/MVP with an actual IR transform; 29 positive/negative regression cases cover verifier validity, idempotence, and before/after execution.

03 / 04

Rust · compiler backend · register allocation · SysV x86-64

x86-64 codegen · Rust

SSA/CFG → liveness → register allocation → x86-64 pipeline. An independent verifier checks register assignments and spills; native execution is compared against a reference IR interpreter.

Problem

The goal is to go from IR to executable x86-64 and verify that register allocation preserves semantics.

Approach

SSA-like IR with CFG/SSA validation, liveness/interference, register allocation with an independent assignment verifier, phi lowering, and SysV x86-64 code generation.

Outcome & limits

A reference interpreter and differential execution check generated-code semantics; the allocator assignment contract is verified independently.

04 / 04

Experimental .NET runtime and performance

Quark2 · generated-code invocation measurements

DynamicMethod/Reflection.Emit and RuntimeMethodHandle; BenchmarkDotNet compares reflection Invoke, delegate and pointer calls on generated methods.

Problem

Public .NET abstractions can obscure invocation overhead and the fragile boundary around CLR internals.

Approach

Experiments with DynamicMethod, Reflection.Emit, RuntimeMethodHandle and native function pointers; BenchmarkDotNet comparisons of Invoke, delegates and pointers.

Outcome & limits

A reproducible research prototype, not a production optimization or a general CLR performance claim.

03 / 04

Technical skills

Technologies are targeted to this CV edition; usage context is in the case studies.

  • C#/.NET, CIL/CLR, DynamicMethod, Reflection.Emit, Roslyn, BenchmarkDotNet; interpreter/CIL backends
  • C++23/LLVM 22, IR/CFG/SSA, LICM, effect analysis, Rust/x86-64 (SysV ABI), differential testing, Git/Linux

Reference projects

04 / 04

Education

HSE University — Software Engineering.

MEPhI Junior 2026, 1st-degree diploma; LangDev 2026 speaker.

Evidence boundaries

Aggregate commercial tenure is candidate-reported. Source availability, a test manifest and freshly executed tests are different evidence levels. TuringSquare-LMS is in development: parts are agent-implemented, payments are sandbox only. None of these statements claim independently verified production behavior.

Read source limitations

Open to conversation / 03

Let’s discuss an engineering problem.

Mikhail Razakov · Moscow / remote

Mikhail Razakov © 2026All profiles ↗