Особисті дані приховані

Dzhymalii Gavran

e-mail: [відкрити контакти](див. вище в блоці «контактна інформація»)

Family status: married

Goal:
Getting C++ Programmer Position

Education:

Vinnytsia National Technical University.
Specialty: Design and development of electronic computing systems.
Technology and production of radio-electronic systems.

Languages:

Ukrainian - Native, English - Advanced.

Review:

I am an experienced developer specializing in creating and optimizing high-load
trading platforms. My experience includes optimizing multi-threaded code and lock-
free data synchronization using atomic operations, non-standard algorithms and
approaches. Development of high-load systems, working with databases and creating
optimized code for trading and business applications. I also have experience with
various network protocols, tools, and libraries.

Professional experience:

Object-oriented design, multithreading, IPC, TCP/IP, UDP, WebSocket, client-server
applications, microservices, OLTP services,
development of Qt-based user interfaces, WebSocket.
Web application development using GWT, GXT, Java, Maven, Tomcat. Experienced
trading platform software developer.
Focused on Linux-based systems with low latency.
Expert in designing high-load systems with discrete response times.
Proficiency in C++11/14/17/2a, software design and implementation.

Programming languages:
С/C++, Java, Python, bash, sql

Technologies:
C++11/14/17/2a, Boost, Boost.Asio, ZeroMQ, GLib, POSIX, Qt4-6, HTML, CSS,
Git, SVN, CMake, GCC, FastCGI, GDB, Valgrind, JDBC, JNI, GWT, GXT, Maven,
SQL, Google Test, Jenkins, Jira, Maven, Docker, PyTorch

Operating Systems:
Linux, Windows

Projects:

• Multithreading information management and data transfer system using
sockets and IPC.

• Development of a network filter based on RAW sockets and Qt.

• Online store, front-end and back-end using Java2EE, GWT, GXT,
Servlet, Tomcat, MySQL, Maven.

• Multiprocessing and multithreading system for online advertising.

• Library for working with financial transactions.

• Cross-platform proxy (SOCKS5) server and client based on
Boost.Asio.

• Web application for bookkeeping and work shift accounting, front-end
and back-end using Java 8, GWT, GXT, Servlet, Tomcat, MySQL,
Maven.

• Client-server architecture for information processing and decision-
making using Python, C++14.

• Multithreading, highly loaded OLTP server with support for various
protocols using C++14, FastCGI, Boost, MySQL, Oracle Database.

• Microservices for embedded systems on Qt5 using QtWebSocket,
SQLite.

• TCP/UDP streaming utility, client and server parts. Extensible through
plugins.

• Highly loaded exchange trading system.

• Low latency memory allocation framework.

Use in in-process and inter-process data storage and exchange. The
approach for writing and reading data from various processes and
threads prevents data locks and ensures data integrity.

• Microservice implementation common code
(start/stop/suspend/resume). Monitoring and management interface
(check status, control commands).

• Multithreading system for managing data exchange between clients

based on sockets and shared memory.

• Messaging protocol framework for latency-critical algorithmic trading
system, including binary protocol design.

• Multithreading backend applications that receive data over redundant
channels using multicast, TCP protocol, synchronization of received
data, processing of data recovery using C++20, ZeroMQ, Boost.Asio,
REST, Prometheus and Grafana, Google Test, SBE protocol.

• Developed embedded video, audio, and data streaming systems on
Linux using V4L2, MPP, and turboJPEG; implemented H.265 (HEVC)
and H.264 encoding on HiSilicon and Rockchip platforms; built RTSP
video streaming services; designed a configuration management system
(apply, store, reset settings); and applied PyTorch for configuration and
tuning of smart camera systems.

•

Company: PNA (Web Accounting Software)
Role: Developer
Team Size: 4 people
Period: 2006 – 2008

Development of the web application for accounting:
The service was designed to organize prompt collection of payments, correct filling
out additional accounting details, and mutual settlements with clients.
Application for monitoring and accounting of shifts and financial reporting for
personnel.
Tech Stack:
GWT, GXT, HTTP, CSS. The server side was developed based on Tomcat and
Servlets.

Company: Banner.ua (Web Advertising Service Provider)
Role: Developer
Team Size: 15-20 people
Period: 2008 – 2010
Support and development of the online advertising system:
The core of the system was implemented in separate FastCGI processes that
processed various types of advertising.
Adding functionality, collecting statistics, optimization, improving synchronization
between processes and saving information, calculation of balances and limits, and
processing ad displays considering geographical locations.

In each process, additional threads were launched for recording statistical data,
receiving control commands and user configuration, storing information in the
database, synchronization, and exchanging data between processes.
Design and development of both front-end and back-end of the website.
SEO optimization for better visibility in search engines.
Report on sales, income, balance, statistics, and creation of online graphs based on
statistical personnel management.
Analytics tools to track user engagement, traffic, and content performance.
Implementation of user authentication and authorization systems.
Tech Stack:
The front-end and back-office parts were developed using GWT, GXT, HTTP, CSS.
The server part was developed based on Tomcat, Servlets, and SQLite.
C++, FastCGI.

Company: SilverCup (Trading Platform)
Role: Developer
Team Size: 8 people
Period: 2010 – 2012

Development of the business logic and exchange trading system:
Development and maintenance of the complex trade platform, introducing new
features and optimizing existing ones.
Collaborated with cross-functional teams to integrate third-party APIs, enhancing
platform functionality. Ensured platform security, scalability, and performance.
Development of the multithreading system for managing data exchange between
clients based on sockets and shared memory.
Development of the highly loaded service for calculating prices and making
decisions. Connection, synchronization, and exchange of data by clients via a two-
way channel to shared memory using the developed data transfer control protocol.
Development of own application layer protocol for data exchange between clients
and managing data processing.
The central server controls the common control channel and coordinates data transfer
between clients.
Implemented a client registration mechanism through a common control channel to
ensure that the server knows about the presence of active clients.
The server accepts commands from clients through the common control channel.
These commands include data transfer requests, shutdown requests, and other control
commands.
Shared memory is used to exchange data between the server and clients. Shared
memory segments are created in which clients write and read data from the server.
Mutexes are used to synchronize access to shared memory between clients and the
server.
Integration with exchanges and banking systems. Developed interfaces for integration
with various exchanges and market data.

Includes analytics and reporting tools for platform users and administrators.
Development of clients for working with various banks and exchanges: City,
Dukascopy, RTS, MMVB.
Development of a multithreading application that receives data via backup channels
using the UDP multicast protocol, synchronization of received data, processing of
lost data by requesting it from the server using its own protocol.
Tech Stack:
C++, IPC

Company: NetLab (Network Security and Proxy Solutions)
Role: Senior Developer
Team Size: 15-20 people
Period: 2012 – 2013

Development of the cross-platform client-server proxy and system for protecting and
controlling network traffic:
Raw sockets and the libnet library were used to process network traffic.
The graphical interface was developed on Qt 4.3, including the installation of options
and settings for the type of packets (ARP, IP, UDP, TCP, ICMP, HTTP).
Allowed and verified IP and MAC addresses, setting up filters and collecting
statistics.
The network and interface components were launched as separate processes. IPC was
implemented using sockets or shared memory, depending on whether the process was
running on a remote or local machine.
Development of a proprietary protocol that allows identification of clients supporting
several encryption algorithms, and transmission of UDP packets wrapped in the TCP
protocol.
Additional commands and attributes allow identification of network data and
connection status.
The system supports both TCP and UDP protocols, with each client on the server
identified by its unique assigned port.
Implementation of the SOCKS5 protocol.
The system allows encrypted data transfer over the network, control of client
behavior, and connection through various applications (e.g., RDC, web browsers,
custom clients).
UDP packets are transmitted via TCP and then received over UDP, controlling the
loss of UDP requests when packets are resent from the endpoint.
Tech Stack:
C++, Boost Asio.

Company: MSL (High-Load Financial and Betting Services)
Role: Senior Developer
Team Size: 300-500 people
Period: 2013 – 2021

Development and Maintenance of OLTP Services:
Developed a client-server architecture for information processing and decision-
making.
Designed and maintained a multi-threaded, high-load OLTP server supporting

various protocols.
Utilized thread pools to manage ready-to-run threads, ensuring optimal resource
usage and preventing excessive thread creation.
Applied microservices to separate functionality, improve scalability, and ensure
reliability.
Accounting Service:
Developed client registration and authorization for both the website and back-office
managers.
Implemented encryption, authentication, and authorization technologies (TLS/SSL)
to ensure secure data transmission and storage.
Provided online statistics with flexible, multi-filter analysis of financial transactions
by time periods, activity, users, services, goods, and balances.
Ensured protection and encryption of personal data.
Supported integration with various payment systems.
General Betting Service:
BetRegistration: Developed a service for calculating game combinations and moves
based on input parameters.
Integrated the system with partners and third-party suppliers for data processing.
Slot Service: Developed the server for online games using WebSocket.
Risk Engine: Developed a service to monitor the balance of bets for gaming events
across different combinations and conditions.
Development of Microservices for Embedded Systems Using Qt5
Supported a proprietary terminal network.
Tech Stack:
C++14, Qt5, Python, Java, GWT, GXT, MySQL, OracleDB

Company: Binaryx (FinTech)
Role: Senior Developer
Team Size: 10 people
Period: 2021 – 2024

Development of the high-load service for trading exchanges:
Development of a universal low-latency memory allocation framework for in-process
and inter-process data storage and exchange.
Optimized multi-threaded algorithms using atomic operations for processing trade
transactions without blocking.
Implemented non-standard data synchronization methods such as "lock-free" and
"wait-free" algorithms.
Generic microservice implementation code.
Monitoring and management interface (check status, control commands).
Developed a multithreading system for managing data exchange between clients
based on sockets and shared memory.
Custom application layer protocol for exchanging data between clients and managing

data processing.
Monitoring of data transmission in the trading system.
Developed a mechanism for service control channels and data recovery.
Developed a framework for synchronized data transfer and recovery between
processes and threads using various types of memory (heap, shared memory, mmap).
Service monitoring system implementation.
Integrated a mechanism for receiving data by REST requests.
Developed an authorization system and managed connections of trade clients to the
system.
Developed a test client for connecting to the trading system and a load testing client
system.
Microservices architecture used to separate functionality, facilitate scaling, and
ensure reliability.
Developed a horizontal scaling platform to handle growing workloads.
Integrated external systems for identifying system performance and health.
Added control automation tools.
Implemented a data backup and recovery system to ensure the platform's
functionality.
Used CI/CD to rapidly develop and deploy changes.
Developed interfaces for clients working with various exchanges and market data.
Analytics and communication tools for users and platform administrators.
Developed and optimized multi-threaded algorithms for a high-load trading system
using atomic operations and custom synchronization methods designed to minimize
blocking and improve performance.
Integrated and supported various network data transfer protocols, including FIX,
TCP, and UDP.
Tech Stack:
C++20, ZeroMQ, Boost.Asio, REST, Prometheus, Grafana, Google Test, and SBE
protocol.

Company: Confidential Embedded Systems HighTech Solutions (NDA)
Role: Senior Developer
Team Size: 4 people
Period: 2024 – Present

Development of Linux-based streaming embedded devices:
Implemented video encoding using HEVC and H.264 standards
Target platforms: HiSilicon and Rockchip
Developed low-latency video pipeline using V4L2 (MMAP/DMABUF) ,
MPP, turboJPEG
Implemented zero-copy data flow via DMA buffers between capture and processing
stages
Developed Linux kernel drivers for I2C devices

Used ioctl, sysfs, and interrupt handling in drivers
Designed and implemented file system management subsystem:
module loading and initialization, recovery mode support
Configured and managed network interfaces:
Ethernet, modem, USB; ensured connection stability and diagnostics
Implemented secure networking:
WireGuard integration, network state monitoring, availability and fault tolerance
control
Developed external storage management:
device detection, mounting, formatting, encryption
Implemented task scheduler for background and periodic operations
Developed networking and streaming services:
HTTP server and client
WebSocket for bidirectional communication
RTSP server for video streaming
Integrated and optimized SQLite database usage
Designed scalable multithreaded data processing pipelines:
handling high-throughput data streams from connected hardware with low-latency
requirements
Implemented data handling pipeline:
file storage, FTP export, network transmission
Developed configuration management system:
applying, storing, and resetting device settings
Implemented user account management system
openCV for configuration and tuning of smart camera systems

Designed and implemented high-load client–server system for real-time processing of
heterogeneous data streams
Backend (C++):
Developed low-latency server handling multiple data stream types (UDP, websocket,
IPC)
Real-time processing of diverse data types depending on processing goals (feature
extraction, ML input, decision logic)
Implemented data normalization and routing layer:
- unified internal representation for different data sources
- dynamic routing of data to processing pipelines
Implemented reliable data delivery over UDP:
- packet sequencing, ACK/NACK, retransmission
- loss recovery, deduplication, out-of-order reassembly
Designed custom flexible binary protocol:
- extensible message schema for multiple data types
- compact serialization with minimal overhead
Built high-performance IPC:

- shared memory (POSIX shm / mmap)
- low-latency inter-process communication
Developed real-time data processing pipeline:
- filtering, aggregation, feature extraction
- preparation of structured inputs for ML models
Python modules:
Implemented algorithmic processing and decision-making logic
Built ML data pipelines using PyTorch
Managed data flow between C++ core and Python modules

Frontend:
Developed GUI client (PySide/Qt) for real-time monitoring and control

Tech Stack:
C++, Bash, Python, Linux, SQLite, WebSocket, RTSP, FTP, V4L2, MPP,
PyTorch, FastAPI, openCV, Gstreamer, FFmpeg

Qt Desktop Application:
Development of internal tools for device management.
Designed and developed application for generating update packages:
operating system updates
software updates
network configuration
hardware configuration

Developed device identity management tool:
device ID generation and provisioning
installation package creation
account data generation and updates

Tech Stack:
C++, Qt6, WinApi