Technical Profile

My engineering work combines applied methods and technology stacks in computer and mechatronics engineering, software development, high-volume data systems, artificial intelligence, signal and image processing, digital forensics, reverse engineering, embedded systems, cybersecurity, and performance engineering.

I relate these methods and technologies to my projects, technical notes, publications, and publicly available software. I describe institutional experience through shareable problem classes, engineering methods, and public technologies, while keeping internal data, infrastructure, security architecture, and operational details confidential.

Engineering Methodology and Design Principles

For production software, especially high-traffic, real-time, or long-running systems, "works correctly" and "is fast" are not sufficient in isolation. Correctness, data integrity, latency, throughput, resource consumption, fault isolation, concurrency, and predictable behavior under production load need to be considered together.

My engineering approach therefore emphasizes:

• treating performance as an end-to-end system property across CPU, memory, allocation, I/O, network, queues, and databases,
• looking beyond average latency to queue growth, tail latency, timeouts, and bounded-resource behavior,
• using capacity limits and backpressure rather than equating higher parallelism with unbounded work creation,
• treating failures, cancellation, timeout, partial failure, retry, and idempotency as normal design concerns,
• validating optimization through measurement, profiling, execution plans, realistic workloads, and end-to-end observation,
• avoiding unnecessary allocation, copying, conversion, and abstraction overhead on critical paths,
• evaluating data-layer behavior through transaction duration, connection-pool use, locking, and query cost as well as functional correctness.

Related material includes High-Performance Java Data Systems, Safe Retry Design in Critical Systems, and IBM POWER9 for Digital Forensics and Artificial Intelligence.

Programming Languages and Applied Experience

I do not select programming languages in isolation. Runtime behavior, memory management, native boundaries, concurrency semantics, target platforms, ecosystem maturity, maintainability, and operational constraints all influence the choice.

This section describes my applied experience. For an academic comparison of language semantics, type systems, runtimes, memory models, concurrency, and paradigms, see my separate Programming Languages course note.

Java and Spring Boot

Java is one of my primary languages for high-volume enterprise backend and service systems. In Spring Boot applications I work across HTTP service layers, data access, transaction boundaries, concurrent processing, long-running services, and Oracle-centered data flows.

The Java work is not limited to framework APIs. JVM behavior, thread and virtual-thread models, executors and queues, connection pools, object allocation, garbage collection, serialization, I/O, and database cost all affect end-to-end latency and throughput.

Related notes: Java Programming, Spring Boot, and High-Performance Java Data Systems.

C

I use C in embedded software, low-level data processing, hardware-near code, binary formats, and systems-oriented problems. Memory layout, pointer semantics, buffer boundaries, ABI behavior, resource lifetime, and determinism become direct engineering concerns in this class of work.

During my Baykar software internship, I worked with embedded C, TMS570, lwIP, and TCP/UDP communication. In digital-forensics and data-recovery work, binary structures and file carving represent another low-level problem class.

Detailed language note: C Programming.

C++

I use C++ for performance-sensitive data, signal, and image-processing workloads, native libraries, multithreaded processing, and problems that combine CPU and GPU computation. In these systems, asymptotic complexity matters alongside data layout, cache behavior, copying cost, SIMD/vectorization, contention, and resource lifetime.

My 2019-2025 machine-learning project engineering work combined C/C++, Python, OpenCV, CUDA, and OpenMP across computer vision, signal processing, and performance engineering.

Detailed language note: C++ Programming.

C# and .NET

My C#/.NET experience includes desktop applications, user interfaces, serial communication, telemetry, data-processing utilities, and engineering tools. Early applied examples include RFID/RS232 and access-control work during my Afyon Kocatepe University IT internship, and telemetry/ground-control software during my Baykar internship.

Alongside the productivity of a managed runtime, I consider allocation, asynchronous I/O, native interaction, and deterministic resource cleanup according to application requirements.

Detailed language note: C# Programming.

Python

Python is one of my primary languages for artificial intelligence, machine learning, speech processing, computer vision, data preparation, inference, and experimental/analytical workflows. My focus is not limited to training or calling a model: acquisition, preprocessing, inference, post-processing, runtime selection, hardware use, and production integration are parts of the same pipeline.

Technologies I have used or studied in this context include TensorFlow, Keras, PyTorch, ONNX, OpenCV, FFmpeg, Kaldi, Vosk, and Whisper.

SQL, PL/SQL, VHDL, and Other Technical Representations

My applied work also includes languages and representations outside general-purpose programming. SQL and PL/SQL are central to Oracle-oriented data systems; VHDL appears in FPGA work; HTML, CSS, and JavaScript are used at the web layer; protocol and binary-format definitions become implementation artifacts in systems integration and reverse engineering.

Mission-Critical Software Architectures and Data Processing

In high-volume and long-running systems, the objective is not simply to execute more work in parallel. Effective capacity is bounded by the narrowest resource across CPU, memory, storage, network, database connections, external services, and queues.

In Java/Spring Boot and Oracle-centered enterprise systems, I therefore consider:

• transaction boundaries and data integrity,
• connection-pool capacity and wait behavior,
• the interaction between application concurrency and database load,
• queue growth, backpressure, and bounded concurrency,
• resource leakage and gradual degradation in long-running services,
• fault isolation, timeout, cancellation, and retry behavior,
• latency-versus-throughput trade-offs at realistic data volumes.

A locally faster component can make the complete system worse. More workers can exhaust a database pool; aggressive retries can amplify a transient fault into a load spike; unnecessary logging or intermediate data can shift the bottleneck to disk and I/O. Optimization is therefore performed against system boundaries rather than a single benchmark.

Dataflow Management and Apache NiFi

Apache NiFi is a dataflow platform for managing acquisition, processing, routing, validation, and delivery across data sources and destinations. My dataflow engineering work addresses the distinction between FlowFile content and attributes, provenance, queue management, backpressure, failure routing, and transaction boundaries.

Java-based custom NiFi processor development covers AbstractProcessor, ProcessContext, ProcessSession, property descriptors, relationships, NAR packaging, lifecycle management, and thread safety. Component contracts, bounded memory, deterministic transformations, safe reprocessing, and testability guide these designs. The methods are explained independently in Developing a NiFi Custom Processor with Java.

Database and Data Systems

Database work is evaluated through consistency, transaction boundaries, query cost, latency, expected workload, and data integrity.

Relational Data Systems

• Oracle: my primary platform for high-volume enterprise data access, transaction management, SQL, execution plans, and query optimization.
• MySQL, PostgreSQL, Microsoft SQL Server, and SQLite: relational systems used or studied for different application, storage, and portability requirements.

Analytical Data Systems

I work with ClickHouse on column-oriented OLAP processing, continuous data ingestion, and high-volume event analytics. For telemetry, log analysis, anomaly detection, and analytics supporting artificial intelligence, I evaluate data freshness, column pruning, aggregation cost, and resource consumption.

Data Access, Search, and Caching

• Redis: caching and low-latency data access,
• MongoDB and Elasticsearch: document-oriented data access, indexing, and search,
• FAISS: similarity search and indexing over high-dimensional vectors.

With Oracle, I evaluate query plans, index selection, transaction duration, concurrency, and the database impact of long-running work together. Functional correctness is necessary, but the I/O, CPU, memory, and locking cost at real data volumes is also part of the design.

This domain is not merely about using database products. It includes the capacity and consistency boundary between application and data layers. In Oracle-centered enterprise systems, I consider execution plans, transaction duration, connection pools, concurrency, and duplicate/dirty-data behavior as one system-level problem.

Related technical work:

• Oracle Database and PL/SQL: Architecture, SQL, and Performance
• Safe Numeric Conversion in Oracle SQL
• Dynamic Data Source Routing with HikariCP
• Advanced Connection Pool Design with HikariCP
• High-Performance Java Data Systems
• Safe Retry Design in Critical Systems

The common principle is that a database is not an isolated storage box. What a query does inside the database, how long a connection remains occupied, and how much concurrent work competes for the same bounded resource directly shape application latency and throughput.

Performance, Concurrency, and Systems Engineering

My performance work across C/C++, Java, and Python is organized around the same question: where is the real bottleneck, and how does an optimization change the behavior of the whole system?

Areas include:

• concurrent and multithreaded programming,
• parallel processing,
• real-time and batch processing,
• algorithm and data-structure optimization,
• Linux system and process behavior,
• OpenMP, CUDA, and GPU computing,
• CPU, memory, I/O, and network bottlenecks,
• queues, contention, locking, and backpressure,
• SIMD/vectorization and data layout,
• deterministic and bounded-resource design.

In an audio-processing pipeline, memory and SIMD behavior may dominate; in a data service, queueing and database cost may dominate; in a digital-forensics tool, data format and verifiability can be equally important. Performance engineering is therefore not reduced to one benchmark number.

Digital Forensics, Cybersecurity, and Reverse Engineering

My digital-forensics and cybersecurity work intersects directly with software engineering. Input data is often incomplete, malformed, undocumented, or untrusted; large binary files, damaged metadata, unknown formats, and partial data are normal problem conditions rather than edge cases.

My work includes:

• static and dynamic software analysis,
• network and PCAP analysis,
• binary data structures and custom file formats,
• reverse engineering,
• file carving and data recovery,
• cryptology and authentication,
• secure data processing and access control,
• analysis of existing system behavior and, when necessary, reimplementation in another language or environment.

Verifiability and evidence integrity matter as much as raw speed. A parser or carving algorithm cannot be considered sufficient merely because it is fast if boundary handling, malformed-input behavior, or false-positive characteristics are uncontrolled.

Artificial Intelligence, Speech, Signal, and Image Processing

I approach artificial intelligence as an end-to-end inference system rather than a model call in isolation. Acquisition, preprocessing, inference, post-processing, hardware utilization, and persistence all contribute to the same correctness and performance path.

My work includes:

• speech recognition and speaker-related processing,
• speech enhancement and digital signal processing,
• computer vision and image processing,
• machine learning and deep learning,
• data preparation, inference, and result processing,
• CPU/GPU workload partitioning and performance optimization,
• integration of machine-learning models with production services.

Technologies I have used or examined include Python, C/C++, TensorFlow, Keras, PyTorch, ONNX, OpenCV, FFmpeg, Kaldi, Vosk, and Whisper.

My 2019-2025 Argus Technology work covered computer vision, deep learning, pattern recognition, signal processing, C/C++, Python, OpenCV, CUDA, and OpenMP. My IBM POWER9 work provides another public context for combining high-performance computing, digital forensics, and AI workloads.

Embedded Systems, Microcontrollers, FPGA, and PLC

Microprocessors, microcontrollers, FPGA, and PLC are not merely a list of platform names in my work. Software on these systems is shaped by timing, interrupts, memory, serial/network communication, peripheral configuration, and physical-system behavior.

Embedded and Microcontroller Platforms

I have worked with Texas Instruments TMS570, MSP430 and Stellaris, STM32, ARM-based systems, and PIC devices. During my Baykar internship, I configured lwIP on a TMS570 development platform and worked with TCP/UDP communication, making the interaction among network-stack behavior, memory, and embedded timing concrete.

The RFID and serial-communication work in my Afyon Kocatepe University IT internship provided another hardware/software boundary between readers, serial data, microcontroller-side behavior, and desktop applications.

Single-Board Computers and Prototyping

• Raspberry Pi
• Odroid
• Arduino

I distinguish Linux-capable single-board computers from small bare-metal microcontrollers. A general-purpose OS introduces processes, scheduling, and driver layers, while smaller controllers expose interrupt and peripheral timing more directly.

FPGA, VHDL, and Industrial Control

• Spartan-6 FPGA
• VHDL
• PLC
• Siemens SIMATIC S7

FPGA design is structurally different from sequential instruction execution: concurrent hardware logic and clock boundaries are part of the implementation model. PLC work places more emphasis on deterministic industrial control cycles, field I/O, and cycle time.

Real-Time Perspective

Average execution time is not sufficient when physical deadlines matter. Interrupt latency, worst-case execution time, jitter, and peripheral deadlines can determine system behavior. The broader context is connected to Mechatronic Systems, Operating Systems, and my Mini UAV software project.

Robotics, Control, and Physical Systems

My mechatronics background means that some software problems must be evaluated within a physical control loop. My 2016-2019 AKINSOFT / AKINROBOTICS work brought robotic control, autonomy, behavior, speech recognition/synthesis, image processing, communication, and telemetry into the same product boundary.

In robotics and embedded systems, sensors, actuators, control loops, communication, software state, and user interfaces all contribute to physical behavior. A software delay may represent more than a slow screen update; it can become a timing error in the physical system.

Development Environments and Toolchains

Development environments and toolchains I have used at different stages of desktop, web, mobile, and embedded software work include:

General-Purpose Development Environments

• Visual Studio
• NetBeans
• Eclipse
• CodeLite

Embedded-System Toolchains

• Code Composer Studio
• IAR Workbench
• Keil uVision

Mobile Development

• Xamarin Studio
• Android Studio

Tool choice depends on the target language, platform, compiler, debugger requirements, hardware, and product lifecycle. In embedded development, an environment is more than an IDE: compiler, programmer, debugger, and target-hardware support form one toolchain.

In current software work, build systems, version control, dependency management, testing, static analysis, profiling, and production-compatible toolchains are often more important than the IDE itself.

Engineering Scope of Professional Practice

The areas in this profile connect through real work across different periods:

• **2014 — Afyon Kocatepe University IT Department:** RFID, RS232, UID processing, databases, serial-port monitoring, and Arduino-based access-control systems.
• **2015 — Baykar software internship:** TMS570, lwIP, TCP/UDP, embedded C, avionics SPI/I2C analysis, static code analysis, C# telemetry, and ground-control software.
• **2016-2019 — AKINSOFT / AKINROBOTICS:** robotic control and autonomy, speech recognition/synthesis, image processing, communication, and telemetry.
• **2019-2025 — Argus Technology:** project-based machine learning, computer vision, deep learning, pattern recognition, and signal processing with C/C++, Python, OpenCV, CUDA, and OpenMP.
• **2019-present — Ministry of Interior:** software engineering in the context of digital forensics, artificial intelligence, big data, and high-volume/real-time software systems.

The timeline is more meaningful than the technology names alone: similar problems involving performance, data integrity, failure behavior, and system boundaries recur across different hardware and software layers.

Academic and Technical Background

My technical work sits at the intersection of computer engineering, mechatronics engineering, graduate-level digital forensics, and cybersecurity. This background reinforces a systems view in which software is considered together with data, operating systems, networks, hardware, security, physical systems, and verifiability.

For a detailed academic history, see Education; for professional chronology, Professional Experience; for implemented work, Projects; and for the broader biography, About.

Graduate Education and Publications Completed During Professional Practice

During my professional work beginning in 2019, I completed the 2020–2021 master's programs in Digital Forensics at Gazi University and Cybersecurity at Marmara University. Related scholarly contributions were published as the Internet of Things and Digital Forensics book chapter in 2021 and the Image and Audio Processing book chapter in 2022. These educational and scholarly activities provide academic foundations in digital evidence, secure software, data integrity, multimedia processing, and applied artificial intelligence.

Publications, Open Source, and Verifiable Technical Outputs

Public technical work is connected to identifiable projects, publications, and software outputs.

• GitHub: public source code and technical projects.
• ORCID: persistent academic identity and publication relationships.
• Google Scholar: academic publication profile.
• Open-Source Research Software: published research/software outputs.
• Publication and Corrections Policy: sourcing, revision, and correction practices used on this site.
• Internet of Things: From Theory to Practice: book-chapter work connecting IoT and digital forensics.
• Artificial Intelligence: From Theory to Practice: book-chapter work in image and audio processing.

These references are intended to support the profile with project, experience, publication, course-note, or source-code evidence rather than relying on unsupported self-description.

Technical Work and Academic Foundations

Practical engineering experience is documented through completed work and projects; Academy courses develop the theoretical and methodological foundations of the corresponding disciplines.

For example:

• Programming Languages explains type systems, semantics, runtimes, memory, and paradigms; this profile explains where I have applied C, C++, C#, Java, and Python.
• Oracle Database and PL/SQL teaches database architecture; this profile explains Oracle's role in my enterprise data-system work.
• Whisper Architecture analyzes ASR technology; this profile places speech processing within my applied AI work.

Keeping these roles separate avoids duplicating the same generic material across URLs while connecting personal experience to deeper educational content.

Institutional Information Security and Publication Scope

This profile contains technical information that can be shared publicly. For institutional or security-sensitive work, it intentionally describes engineering domains, public technologies, and problem classes without disclosing internal system names, credentials, private datasets, infrastructure topology, or operational-security details.

Across these domains, the common engineering priorities are correctness, measurable performance, reliability, controlled use of bounded resources, and predictable behavior under real production conditions.