Vladlen Naumov
C++ Developer
4+ years exp
C++
Python
Bash
C
Assembly
Active 22 days ago
+7 (996) 3163560 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A generalist C++ developer at a lower-middle (early middle) level who builds multithreaded desktop and systems utilities. The strongest proven skill is concurrent C++ and low-level data-structure work, evidenced by the atomic queue implementation (Labmem-015/two_queues/include/atomic_queue.hpp) and coroutine scaffolding (Labmem-015/two_queues/include/async.hpp). The work shows limited attention to correctness and production hardening - there are unsafe manual allocations, UB-prone pointer arithmetic, race-prone lock usage and no CI/tests or MCU/driver firmware artifacts.
Technical skills
C++• Middle • 4y+
Python• Middle • 4y+
Bash• Middle • 3y+
C• Junior • 3y+
Assembly• Junior
C++
PyTorch C++
VCPKG
STL
CMake• 3y+
Asio
Python
FastAPI
Requests
Pydantic
Typer
Assembly
WinDbg
AI/ML
NumPy
PyTorch
Scikit-learn
OpenAI SDK
Torchvision
OpenCL• 3y+
OpenCV• 3y+
DevOps
CI/CD
Rest API
Git
GitLab CI
KVM
QEMU
Analytics
Matplotlib
Cybersecurity
Wireshark
QA
Postman
Timeline
C++ Developer
•
Middle
AV Soft
•
Full-Time
Developed Windows user-space software for collecting events to support behavioral analysis of malicious activity. Worked with asynchronous and multithreaded event validation, packaging, and sending to external web services used in the research workflow. Implemented tooling to manually start and monitor driver state from user space for debugging and worked on kernel-space drivers research, refactoring, and R&D for exception handling portability on x86. Also reorganized builds and CI/CD pipelines and participated in code reviews, interviews, and customer troubleshooting visits.
C++
CMake
Asio
Python
QEMU
KVM
Bash
GitLab CI
Git
Wireshark
Postman
Assembly
C++ Software Engineer
•
Middle
GosNIIAS
•
Full-Time
Developed embedded software components for a MIPS-based onboard computer that processes sensor data from UAVs. Implemented and refined modules for reliable data transmission over radio, routing logic, and making integrated decisions from processed results. Participated in testing and debugging of image reception, processing, and results storage modules, including transition from clustered computations to onboard equipment. Supported deployments in field conditions through testing, debugging, and product administration.
C++since 2023
C
CMakesince 2023
OpenCV
OpenCL
Pythonsince 2023
Bashsince 2023
Russian Technological University
Bachelor's Degree •
09.03.03 Computer Science
Middle AI/ML Engineer
Confidence: Medium ML Engineer
A practical ML engineer at an early-to-mid level who produces runnable end-to-end examples in both LLM integration and simple PyTorch training. The strongest proven skill is implementing and running a custom training loop and MLP for MNIST - evidenced by the FullyConnectedNN class and the train/test functions in main.py. The public code lacks experiment management, robust evaluation, model-serving best practices, and evidence of advanced research or production-grade LLM orchestration.
Model Architecture & Training
3/10
How well models are designed and trained
Custom training loop and a hand-written MLP architecture implemented in PyTorch for MNIST, but limited to a toy MLP and lacking experimental rigor or advanced training best practices.
Evidence
mnist-classification/main.py: class FullyConnectedNN
mnist-classification/main.py: train() and test() functions
Data Pipeline & Feature Engineering
2/10
How data is prepared for models
Basic data ingestion using torchvision.datasets and DataLoader with minimal transforms and no augmentation or leakage protection.
Evidence
mnist-classification/main.py: datasets.MNIST(...) and DataLoader(...) usage
Experimentation & Evaluation
1/10
How results are measured and tested
Very light evaluation - prints accuracy and loss plots locally; no experiment tracking, validation protocols, baselines, or reproducibility features.
Evidence
mnist-classification/main.py: test() prints accuracy and loss; plotting loss_history/loss_history_log
MLOps & Deployment
2/10
How models are shipped to production
Contains a simple FastAPI service and a CLI that call an LLM endpoint and save a torch.state_dict, but no robust serving, versioning, monitoring, or deployment automation.
Evidence
llm-pipeline/src/nortllm/server.py: FastAPI endpoint /chat/{session_id}
llm-pipeline/src/nortllm/pipeline.py: OpenAI client usage
mnist-classification/main.py: torch.save(model.state_dict(), "model.pth")
Computational Efficiency
1/10
How efficiently computing resources are used
Minimal efficiency considerations - simple device selection and standard DataLoader batching only; no profiling, memory/throughput optimization, or quantization evidence.
Evidence
mnist-classification/main.py: device = 'cuda' if torch.cuda.is_available() else 'cpu'
mnist-classification/main.py: DataLoader(..., batch_size=BATCH_SIZE)
Research Depth & Innovation
1/10
Depth of research and new ideas
No evidence of novel research, paper implementations, or advanced algorithmic innovation - implementations are straightforward and educational in nature.
Evidence
mnist-classification/main.py: simple MLP implementation without custom layers or paper references
llm-pipeline/src/nortllm/pipeline.py: simple API calls to OpenAI client (api wrapper)
Expertise
LLM• Middle
Computer Vision & Image Analysis• Middle
Industries
Artificial Intelligence• Middle
Software• Middle
Technologies
Python• Middle • 4y+
Rest API
OpenCV• 3y+
FastAPI
Scikit-learn
GitLab CI
OpenCL• 3y+
OpenAI SDK
Asio
CI/CD
NumPy
Git
PyTorch
PyTorch C++
Pydantic
Requests
Typer
Torchvision
KVM
QEMU
Recommendations
- Build reproducible experiments: add fixed seeds, train/validation/test splits, and experiment tracking (W&B or MLflow) for the MNIST project.
- Improve ML correctness and robustness: remove Softmax before CrossEntropyLoss, add proper metrics aggregation, and include unit tests for data pipeline components.
- Harden the LLM pipeline: add structured error handling, retries/backoff, auth handling (avoid printing secrets), and simple monitoring/logging for requests.
- Add deployment and MLOps work: containerize the FastAPI app, add CI/CD pipeline, and include model versioning and health checks for serving.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Game Developer
Confidence: Medium Generalist
A pragmatic C++ generalist at an early-middle level who builds small native tools and visualization prototypes. The strongest proven skill is native rendering/tooling with raylib and CMake, evidenced by CMakeLists.txt linking raylib and the App/Graph C++ implementation (app.cpp, node.hpp). There is little evidence of game systems, custom rendering pipelines, profiling data, networking, or editor-scale tooling in public code.
Gameplay Systems & Mechanics
1/10
How game logic works
Minimal gameplay systems; a simple Graph/Node data model is present but there are no game mechanics, state machines, or decoupled gameplay systems.
Graphics & Rendering
3/10
Drawing game visuals
Basic rendering code using raylib API (immediate-mode draw calls). No custom shaders, custom render passes, or batching/LOD strategies are present.
Physics & Math
1/10
Game physics and math
Only basic spatial data (x,y) for nodes exists; no custom integrators, collision logic, deterministic timestep, or spatial partitioning.
Engine Proficiency
3/10
Skill with the game engine
Shows practical engine/toolchain usage - modern CMake, vcpkg check, precompiled headers, and use of raylib; evidence of thoughtful build setup though not advanced engine extensions or editor tooling.
Evidence
Labmem-015/graph-creator/CMakeLists.txt: checks ENV{VCPKG_ROOT}, target_precompile_headers, find_package(raylib) and glfw3
Labmem-015/graph-creator/src/main.hpp: includes modern C++ headers and third-party includes
Labmem-015/graph-creator/src/app.hpp: organized App class with static instance and atomic state
Performance & Frame Budget
2/10
Keeping the game smooth
Some awareness of concurrency and frame loop concerns (atomic flags, comments about threading), but no measured profiling, zero-alloc hot paths, pooling, or concrete frame-budget optimizations.
Content Pipeline & Tooling
2/10
Tools for game content
Basic build and project tooling present (CMake, vcpkg-aware check, precompiled headers). No asset import automation, CI, or editor importers are present.
Verified artifacts
Expertise
Game Development Tools & Pipeline• Middle
Technologies
VCPKG
STL
Recommendations
- Develop small native editor tools and graph/visualization utilities that leverage raylib or similar lightweight renderers.
- Work on CMake-based C++ tooling, adding CI and measured profiling to demonstrate frame-budget optimizations.
- Expand to editor-facing features - import/export, serialized asset formats, and versioned save systems to strengthen tooling portfolio.
- Iterate on deterministic update loops and simple pooling/zero-alloc patterns for hot paths to show systems-level performance work.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Embedded Engineer
Confidence: Medium Generalist
A generalist C++ developer at a lower-middle (early middle) level who builds multithreaded desktop and systems utilities. The strongest proven skill is concurrent C++ and low-level data-structure work, evidenced by the atomic queue implementation (Labmem-015/two_queues/include/atomic_queue.hpp) and coroutine scaffolding (Labmem-015/two_queues/include/async.hpp). The work shows limited attention to correctness and production hardening - there are unsafe manual allocations, UB-prone pointer arithmetic, race-prone lock usage and no CI/tests or MCU/driver firmware artifacts.
Embedded & Firmware
2/10
Low-level device code
Some concurrent and low-level C++ work is present (atomic-based queue, coroutine Task/Awaitable, threaded app loops), but implementations contain correctness and memory-order bugs and no ISR/RTOS or MCU-targeted firmware evidence.
Evidence
Hardware-Software Interface
Connecting code to hardware
Not evidenced in public code
Resource Constraints
1/10
Working with limited resources
Some manual memory and allocation patterns appear (malloc/new usage and manual buffer packing) but there is no evidence of deliberate constrained-memory design, linker scripts, or measured budgets.
Real-time & Timing
2/10
Precise timing control
Basic timing and loop-rate measurement exists (steady_clock, call_time/interval_time) and sleep-based loops are used, but no WCET analysis, priority design, or timer/capture-based real-time architecture is present; delay-driven loops are used.
HDL & Circuit Logic
Designing digital circuits
Not evidenced in public code
Reliability & On-device Testing
2/10
Testing on real hardware
Some reliability-minded code exists (destructor cleanup, try/catch around main loops), but there is no evidence of watchdog strategies, OTA/rollback, HIL tests or field-failure analysis; concurrency and memory-safety bugs reduce reliability.
Expertise
Low-level Development & Tooling• Middle
Technologies
C++• Middle • 4y+
CMake• 3y+
Recommendations
- Assign to develop multithreaded C++ tooling or desktop utilities where iteration and debugging are possible (e.g., data processing tools, graph/visualization prototypes).
- Have the developer implement and harden lock-free or concurrent queues under mentorship - fix memory-ordering, eliminate UB, and add tests and benchmarks (use dedicated unit tests for push/pop concurrency).
- Avoid trusting this developer alone on safety-critical or embedded firmware (MCU drivers, ISR work) until they demonstrate register-level driver work, deterministic timing design and formal tests.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: