Yevgeniy Starinets

Key features:

• Feature-Sliced Design (FSD) architecture with strict layer separation — app, pages, features, entities, widgets, and shared layers with custom ESLint plugin to enforce architectural boundaries;
• Custom Reducer Manager for dynamic Redux slice injection — reducers are loaded on demand with code splitting, reducing initial bundle size and improving performance;
• Redux Toolkit with RTK Query for API management, async thunks for complex logic, and typed selectors for type-safe state access;
• Comprehensive internationalization (i18n) with language detection, dynamic translation loading, and support for multiple locales (English/French);
• Advanced code splitting strategy — every page lazy-loaded, dynamic module loader for feature reducers, and chunk optimization for optimal loading performance;
• Complete blog functionality — article CRUD operations, rich text editing, commenting system, user profiles, authentication flow, and admin panel with role-based access;
• Storybook-driven component development with 60+ stories, addon integrations for testing UI states, and isolated component development workflow;
• Production-grade TypeScript setup with strict mode, path aliases, proper module resolution, and comprehensive type coverage across the entire codebase;
• Custom FSD slice generator CLI tool — automated creation of new features with proper folder structure, boilerplate files, and architectural compliance out of the box.

This project demonstrates how to build a scalable React application with proper architectural patterns, emphasizing code organization, type safety, and maintainability for large-scale production systems.

Key features:

• Custom game loop built with requestAnimationFrame and delta-time calculations, keeping update logic fully frame-rate–independent and cleanly separated from rendering;
• State machine covering Menu, Gameplay, Pause, Next Level, Results, and Game Over — each state manages its own lifecycle (start / update / render / exit) and transitions via a typed event bus;
• Service locator / DI container — a single GameContainer is passed through all systems and states, replacing global singletons with a typed, testable dependency graph;
• Custom EventEmitter with typed event constants and unsubscribe tokens, enabling fully decoupled communication between entities, world, and UI layers;
• Object pooling for projectiles and explosions — zero heap allocation after warm-up, with a reusable init() pattern separating construction from configuration;
• Pure-function collision detection — AABB with directional bounds prediction, tile range lookup, and wall hit logic extracted into stateless utility functions with full unit test coverage;
• Visual level editor with a 26×26 tile grid, enemy wave configuration, undo/redo stack, and localStorage persistence — fully integrated with the main game's custom campaign mode;
• 7 power-up types (helmet, clock, shovel, star, grenade, tank, pistol) with timed effects, persistent cross-level state (stars, lives), and sound/animation synchronization — plus 2-player co-op with shared enemy pool and independent resurrection logic.

This project became a practical proving ground for applying software architecture patterns — state machine, event-driven design, object pooling, dependency injection — in a domain where their trade-offs are immediate and measurable. The 199-test suite and ~45% coverage reflect a deliberate effort to keep core systems independently testable, not just playable.

Key features:

• Fixed-timestep game loop with accumulator — logic updates run at a fixed tick rate (matching the original's ~100 FPS timer), fully decoupled from the rendering frame rate, preventing physics drift and ensuring deterministic gameplay;
• Scene stack (push/pop/replace) — a direct port of the original AS3 GameSceneStack, allowing scenes to be layered, paused, and resumed without teardown, cleanly separating menus, gameplay, and transition states;
• 12-layer Z-order rendering system — mirrors Flash's DisplayList using named PixiJS containers (Background → Floor → Player → TextLayer → AfterAfterTextLayer), giving precise control over draw order for every entity type;
• BFS flood-fill pathfinding grid — a 20×15 cell grid seeded at the player's position and expanded outward each tick; all 20+ enemy types read their movement direction in O(1) from the pre-computed map, faithfully porting the original PathFind.as;
• Procedural weapon generation — 5 weapon classes × 3 tiers × 6 combinable plugins (FlyThrough, Freeze, Knockback, RateOfFire, Speed, Splash) with episode-scaled rarity, producing hundreds of distinct weapon variants;
• JSON-driven difficulty and toughness system — per-mission difficulty rules loaded at runtime assign enemies to one of four toughness tiers (green/blue/red/yellow), each rendered via a PixiJS ColorMatrixFilter that rotates the red enemy sprite colour, porting the original AS3 colour-matrix tinting logic exactly;
• Faithful entity hierarchy — a deep class tree (GameObject → GameObjectBase → EnemyBase / PlayerBase / BulletBase) mirrors the original AS3 structure 1-to-1, with smooth rotation, per-object animation, and AABB wall collision built into every layer.

This project demonstrates the ability to read and reverse-engineer a large legacy codebase (250+ AS3 classes), map its architecture to a modern typed language, and rebuild non-trivial game systems — pathfinding, procedural generation, physics, and rendering — from scratch in TypeScript without losing fidelity to the original.

• Pure TypeScript implementation with no external libraries or frameworks;
• Runs entirely in the browser using IndexedDB for storage;
• Modular architecture with clear separation of concerns;
• Designed to be extensible and maintainable, with clean code and documentation.

Key features:

• Custom kernel with an 8-phase boot sequence, service registry (IoC container), and ordered dependency initialization — mirroring real OS runlevels;
• Middleware-based IPC bus with typed channels, event tracing, and Koa-style next() pipeline — any middleware can block an event before it reaches handlers;
• Capability-based app sandboxing — each app receives permission-checked proxies to system services, with per-app VFS access control and full audit logging;
• Persistent Virtual File System backed by IndexedDB with Unix-like paths, mkdir -p semantics, metadata, and a mountable driver interface;
• Signal-based reactive UI framework built from scratch (no React/Vue) — lightweight components with create / mount / destroy lifecycle and fine-grained reactivity;
• Composable window manager with drag, resize (8-directional handles), edge-snapping zones, z-index stacking, and taskbar-aware maximize;
• Unix-style shell with 50+ commands, pipe (|) and redirection (>, <, >>) support, plus grep, awk, sed, chmod, curl, tar, and more;
• Dynamic app ecosystem — manifest-driven apps loaded on demand, with file-type associations, an app installer, and process lifecycle management.

The iRidium Awards is an international competition recognizing outstanding projects in building automation, smart home control, and integration software.

The “Private House” project — a 3-storey residence in Almaty (Kazakhstan) — implemented a smart home system covering 33 rooms, including bedrooms, study, gym, pool, and home cinema.

Control was realized via 4 iPads, phones and web application, managing lighting, climate, media, and outdoor systems.

The project was evaluated by a professional jury based on:

• Technical and architectural complexity
• Quality of automation logic and programming
• Usability and control interface design
• Overall functionality and innovation