Computer Engineering Course Projects Portfolio

This repository contains a collection of projects, assignments, and laboratory work completed during my Computer Engineering studies. The repository is organized by course, and each folder demonstrates the practical application of theoretical concepts learned throughout the curriculum.

Below is a professional index summarizing the core technologies and capstone projects completed across the curriculum. Click on any course name to jump directly to its detailed section.

📚 Course Projects Index

Course	Primary Technologies	Key Project Highlight
Algoritmaya Giriş (Introduction to Algorithms)	C	Foundational algorithms, Student Grading & Text Parsing
Bilgisayar Ağları (Computer Networks)	NS2, TCL, Python	9-node Star Topology Simulation & Traffic Analysis
Bilgisayar Organizasyonu ve Mimarisi (Computer Organization and Architecture)	Logisim, Machine Code	Morris Mano Basic Computer Architecture Simulation
Bilgisayar Projeleri (Computer Projects)	Python (Pandas)	Alibaba Cluster Trace Analysis & Cloud Orchestration
Elektronik Devreler (Electronic Circuits)	Proteus	Analog/Digital Circuits & PicoBlaze Architecture
Girişimcilik (Entrepreneurship)	Technical Writing	TÜBİTAK Grant Proposal for Autonomous Fire Drones
Görüntü İşleme (Image Processing)	Python, OpenCV	Traffic Surveillance & PCB Defect Detection
İşletim Sistemleri (Operating Systems)	C, Java, WinAPI	Thread Synchronization & Dijkstra's Banker's Algorithm
Mikroişlemciler (Microprocessors)	8085 Assembly, Proteus	8085 Assembly Programming for LED Traffic Lights
Otomata ve Biçimsel Diller (Automata and Formal Languages)	Python (NetworkX)	DFA Generation & Animated Turing Machine Simulation
Programlama 2 (Programming 2)	C#, ASP.NET Core MVC	Full-Stack .NET MVC Architecture & Authentication
İşaretler ve Sistemler (Signals and Systems)	Python (librosa, SciPy)	Audio Noise Reduction & Frequency Filtering
Sistem Programlama (System Programming)	Python (Tkinter)	Custom Built MSP430 Assembler & ELF Generator
Veri Madenciliği (Data Mining)	Python (Scikit-Learn)	Laptop Price Classification & EDA Pipeline
Veri Yapıları (Data Structures)	C++	Automated DFS Maze Solver & Terminal Animation
Veritabanı Yönetim Sistemleri (Database Management Systems)	SQL Server (T-SQL)	Relational Database for Turkish Election System
Yapay Zekanın İlkeleri (Principles of Artificial Intelligence)	Python	Reinforcement Learning Q-Learning Agent (Tic-Tac-Toe)
Yapay Öğrenmenin Temelleri (Fundamentals of Machine Learning)	Python (Scikit-Learn)	Drone Logistics, Clustering & Dijkstra Pathfinding
Yazılım Mühendisliği (Software Engineering)	Python, Gemini API	'Song-to-Anki-Deck' Full-Stack Generation Tool

---

Algoritmaya Giriş (Introduction to Algorithms)

This directory contains foundational C programming projects and exercises focusing on core algorithmic logic, loops, multi-dimensional arrays, and control structures. The main highlight of this course is a collection of four distinct mini-projects.

🔗 View the complete project repository on GitHub

1. Student Grading System (proje-1.c): A program that calculates the final letter grades (AA, BA, BB, etc.) for a dynamic number of students. It processes various weighted components including midterms (45%), two projects (20% each), and assignments (15%) to calculate a semester average, which is then weighted against the final exam score (55%).
2. Hospital Appointment System (proje-2.c): A multi-dimensional array-based system for managing patient appointments. It allows registering multiple appointments for patients across different months and days while enforcing a strict limit of a maximum of 5 appointments per day.
3. Text Analyzer (proje-3.c): A string processing program that parses a given paragraph of text and calculates statistics such as the total word count, number of vowels, number of consonants, total sentences (by parsing periods), and identifying email addresses (by parsing the @ symbol).
4. Prime Triplets Finder (proje-4.c): A specialized mathematical algorithm designed to check if a user-provided integer forms a "prime triplet" (asal üçüz). It uses a custom prime-checking function to verify if the numbers n, n+2, and n+6 are all prime simultaneously.

In addition to the mini-projects, the folder contains various single-file scripts demonstrating introductory concepts such as factorial calculations, basic four-operation calculators using do-while loops, and nested loop structures.

Bilgisayar Ağları (Computer Networks)

In this course, I completed a series of three interconnected projects focused on computer network simulations using the Network Simulator 2 (NS2) and Network Animator (NAM) environments. The projects progressed from initial environment setup to complex topology simulations and data analysis:

1. Environment Setup: Configured a Linux Virtual Machine (MX Linux via VirtualBox) and installed the necessary NS2 simulator and NAM packages via the command line to prepare for network simulations.
2. Star Topology Simulation: Conducted a comprehensive simulation of a 9-node Star Topology network using a TCL script. Node 4 acted as the central hub. The simulation simultaneously tested two different types of network traffic:
   • A TCP connection simulating an FTP application transferring data from Node 0 to Node 8.
   • A UDP connection simulating Constant Bit Rate (CBR) traffic between Node 1 and Node 7.
3. Tracefile Analysis and Visualization: Developed a Python-based data analysis pipeline to parse the .tr tracefiles generated by the NS2 simulations. The script filtered network events for specific nodes and utilized a graphing library to visually plot and analyze output traffic and throughput over time.

Bilgisayar Organizasyonu ve Mimarisi (Computer Organization and Architecture)

This folder features a complete logic design and computer architecture project built using Logisim. The primary project is a functional simulation of the Morris Mano Basic Computer Architecture. Key components and files include:

1. CPU and Circuit Design (logisim-circuits/morris-mano-computer.circ, logisim-circuits/cpu-components.circ): The visual Logisim circuit files where the entire processor architecture is constructed, including the Arithmetic Logic Unit (ALU), registers, control unit, and I/O logic.
2. Memory and Machine Code (memory-dumps/): The project includes several memory image files formatted for Logisim (v2.0 raw). These contain actual hex machine code instructions designed to be loaded into the simulated computer's memory to test its functionality. Notable test programs include:
   • 12+18.txt: A machine code program that successfully executes the addition of 12 and 18 on the custom architecture.
   • io.txt, proje1.txt: Scripts testing Input/Output operations and memory read/writes, proving the complete operational capability of the designed Morris Mano computer.

Bilgisayar Projeleri (Computer Projects)

In this course, I explored advanced topics in cloud computing, container orchestration, and large-scale cluster management. I completed three distinct research projects and data analyses that build upon each other:

1. Large-scale Cluster Management with Borg: Conducted a critical review of Google's landmark paper, "Large-scale cluster management at Google with Borg." Explored core orchestration concepts such as cell sharing, priority and quotas, workload types, and resource reclamation architectures.
2. Virtualization Performance Analysis: Analyzed the study "Virtualization in Cloud Computing: Moving from Hypervisor to Containerization." Delivered a technical comparison of CPU, memory, and disk I/O overheads between traditional hypervisor-based Virtual Machines and modern lightweight containerization.
3. Alibaba Cluster Trace Analysis (Final Project): Engineered a comprehensive data analysis pipeline that empirically tested the concepts from the previous two assignments using the massive Alibaba Cluster Trace 2018 dataset. The code for this is maintained in the final projesi/ directory:
   • Data Acquisition (batch.sh): A bash script to download gigabytes of compressed trace metadata (machine_usage, container_usage, etc.) from Alibaba's servers.
   • Data Analysis Engine (sscript.py): A robust Python script utilizing pandas and matplotlib to conduct four major experiments: Machine Utilization (finding memory as the primary bottleneck), Over-provisioning Analysis (identifying reclaimed idle capacity), Workload Comparison (online services vs. batch jobs), and Container Density per physical machine.
   • Data Visualization: Plotted complex CDF and scatter plots showing live cluster resource telemetry and workload behavior.

Elektronik Devreler (Electronic Circuits)

This directory houses a diverse collection of electronic circuit design and simulation projects, all built and tested using the Proteus Design Suite (.pdsprj files) and consolidated under the exercises and homeworks/ folder. The projects represent the practical laboratory work and term assignments for the course, spanning both analog and digital electronics. Key simulations include:

1. Analog Circuits:
   • Positive Parallel Clipper (pozitifparalelkirpici.pdsprj): A fundamental diode application circuit designed to clip or remove the positive half-cycle of an AC input signal.
   • LED Control Circuits (ledkontroldevresi.pdsprj): Basic circuit designs focusing on current limitation, switching, and safe LED operation.
2. Advanced Digital & Microcontroller Simulations:
   • PicoBlaze Architecture (New picoblaze.pdsprj): A simulation involving the PicoBlaze 8-bit soft-core microcontroller (originally by Xilinx). This project bridges the gap between basic electronics and embedded systems by simulating microcontroller instruction execution and I/O handling in Proteus.
3. Laboratory Experiments: A structured series of weekly lab tasks (deney4, lab7-1) and larger mid-term/final projects (labproje1, proje-1 to proje-4) that progressively test circuit analysis, component integration, and debugging skills.

Girişimcilik (Entrepreneurship)

This course focused on the practical aspects of entrepreneurship, R&D management, and technical project planning. The core objective of the class was to simulate the complete lifecycle of proposing an innovative tech startup idea and seeking government funding. Key accomplishments include:

• TÜBİTAK 1002 Grant Proposal Drafting: Actively drafted a formal grant application for the Scientific and Technological Research Council of Türkiye. The project centered around an Autonomous Forest Fire Detection and Intervention Drone System. This involved rigorous academic and business planning, including:
  • Financial Planning: Creating detailed budgets for R&D equipment, travel expenses for field tests, and calculating stipends for student researchers.
  • Technical Architecture Design: Planning the integration of thermal cameras, GNSS, SLAM navigation, and CNN/RNN-based artificial intelligence models for real-time fire detection, alongside an eco-friendly chemical extinguishing module.
  • Risk Management: Identifying potential technical failures (e.g., GPS loss in forests, battery overheating) and formulating concrete fallback plans (e.g., using LIDAR).

Görüntü İşleme (Image Processing)

This course provided extensive hands-on experience with computer vision algorithms and image processing libraries (OpenCV, Pillow, Scikit-Image). The curriculum culminated in two major, highly technical projects:

• Traffic & Pedestrian Surveillance System (Midterm Project: vize/traffic_tracker.py): Developed a real-time video analysis tool to monitor an intersection and enforce traffic rules.
  • Object Tracking & Speed Calculation: Utilized the Lucas-Kanade Optical Flow algorithm to track moving objects across frames and calculate their relative pixel speeds.
  • Classification: Differentiated between vehicles and pedestrians by analyzing bounding box aspect ratios (pedestrians being taller/thinner) and color variance within the object contours.
  • Rule Enforcement Logic: Implemented an interactive GUI allowing users to manually map crosswalks and sidewalks via mouse clicks. The script then actively flagged jaywalking pedestrians (in yellow) and cars illegally entering occupied crosswalks (in purple).
• PCB Defect Detection System (Final Project: final/pcb_analyzer.py, final/pcb_test.py): Engineered an automated visual inspection script to identify manufacturing errors ("missing holes," "mouse bites," "open circuits") on Printed Circuit Boards.
  • Feature Matching & Alignment: Extracted features using the ORB (Oriented FAST and Rotated BRIEF) algorithm and computed a homography matrix via RANSAC to perfectly align defective images with a golden reference image.
  • Defect Extraction: Applied absolute differencing, binary thresholding, and morphological closing operations to isolate anomalies. Detected contours were then compared against ground-truth XML bounding boxes to evaluate the model's accuracy.

İşletim Sistemleri (Operating Systems)

This course provided a deep dive into the low-level mechanics of operating systems, focusing on process synchronization, resource allocation, and direct system call programming. Key accomplishments include:

• Concurrency & Deadlock Management: Developed multiple multi-threaded applications in C and Java to simulate and solve classical concurrency problems.
  • Implemented POSIX thread (pthread) synchronization in C (c-projects/posix-deadlock-resolver/deadlock.c), utilizing pthread_mutex_trylock to actively prevent race conditions and resolve deadlocks by intelligently releasing held locks when resources are unavailable.
  • Programmed a complete Java simulation of Dijkstra's Banker's Algorithm (java-projects/banker/) to model safe resource allocation and ensure the system never enters an unsafe deadlock state. Various other thread synchronization exercises are archived under java-projects/.
• OS System Calls: Interacted directly with the Windows Operating System kernel by writing C programs (c-projects/winapi-file-reader/winapi_file_reader.c) that utilize the native Windows API (e.g., CreateFile, ReadFile, CloseHandle) to perform low-level file I/O operations without relying on standard C library wrappers.

Mikroişlemciler (Microprocessors)

This course bridged the gap between low-level software programming and digital hardware interfacing. The core focus was on understanding microprocessor architecture through hands-on simulation and Assembly language programming. Key accomplishments include:

• 8085 Assembly Programming (main_traffic_light.sim): Wrote low-level Assembly code to control a custom 40-LED matrix display for a "Traffic Light Simulation".
  • Utilized core 8085 instructions (MVI, OUT, CALL, JMP) to output hexadecimal values to specific ports to draw characters ('D' for Stop, 'G' for Go, '!' for Warning) on the LED matrix.
  • Implemented custom timing delay subroutines using nested register decrementation loops (LXI, DCX, JNZ) to control the traffic light phases.
• Microprocessor Hardware Interfacing (logisim_architecture.circ, proteus_led_interface.pdsprj): Designed the physical circuit architecture in Logisim-Evolution and Proteus to connect the 8085 microprocessor to the 40 LEDs.
  • Engineered an efficient bus-splitting technique: utilizing 4 bits of the 8-bit data bus to carry the LED payload, and the remaining 4 bits as control signals fed into a 4x16 decoder to multiplex the data across ten 4-bit registers.

Otomata ve Biçimsel Diller (Automata and Formal Languages)

This course explored the theoretical foundations of computation by translating abstract mathematical state machines into programmable software models. Key accomplishments include:

• State Machine Generation & Visualization (main.py): Developed a Python engine utilizing the networkx library to programmatically generate random Deterministic Finite Automata (DFAs). The script maps out states, alphabets, and transitions, rendering them as directed visual graphs using matplotlib.
• Turing Machine Simulation & Animation (turing_machine_logic.txt): Designed an algorithmic pipeline to automatically convert any generated DFA into a functional Turing Machine.
  • Implemented dynamic, frame-by-frame visual animations (matplotlib.animation) to simulate the Turing Machine's execution. The animation tracks the read/write head moving across an infinite tape, providing a real-time visualization of state transitions until a HALT condition is met.

Programlama 2 (Programming 2)

This course provided a practical introduction to backend web development using Microsoft's .NET ecosystem. The primary project was building a foundational C# ASP.NET Core MVC Web Application.

🔗 View the complete project repository on GitHub

• MVC Architecture Implementation: Developed a structured web application separating concerns across Models (UserModel.cs), Views, and Controllers (HomeController.cs, ProductsController.cs, UserController.cs).
• Custom Routing & Authentication: Configured complex URL routing patterns in Program.cs to handle dynamic product details and user operations.
  • Implemented an in-memory user authentication system utilizing HTTP GET and POST requests to securely process login credentials, utilizing TempData for error handling and session feedback.

İşaretler ve Sistemler (Signals and Systems)

This course bridged digital signal processing (DSP) theory with practical application. The core project was a Python-based Audio Noise Reduction System designed to clean noisy voice recordings. Key accomplishments include:

• Frequency & Time-Domain Filtering: Utilized scipy.signal to implement a Butterworth Band-pass filter (80–1200 Hz) to isolate human vocal frequencies, paired with a Wiener filter to statistically suppress continuous background noise.
• Feature Extraction & Clustering: Engineered a custom transient noise detection algorithm.
  • Calculated short-time frame energies to identify high-variance segments, extracting their 13-dimensional MFCC (Mel-Frequency Cepstral Coefficients) using librosa.
  • Applied K-Means Clustering (scikit-learn) to autonomously classify frames as either 'clean' or 'noise'.
• Dynamic Attenuation & Analysis: Developed a custom algorithm to suppress noise by mathematically normalizing the dB levels of noisy frames against their nearest clean neighbors.
  • Visualized the results by plotting Time Waveforms, FFTs, and Spectrograms via matplotlib, benchmarking the pipeline's success through SNR (Signal-to-Noise Ratio) and MSE (Mean Squared Error) metrics.

Sistem Programlama (System Programming)

This course provided a rigorous examination of system-level tools by building them from the ground up. The capstone project was the development of a fully functional Custom MSP430 Assembler. Key accomplishments include:

• Assembler Architecture & Parsing: Engineered a modular Python application from scratch that translates human-readable MSP430 Assembly language into raw machine code.
  • Implemented custom modules for lexical analysis (parser.py, expressions.py) and instruction mapping (opcodes.py, operand.py) to systematically decode assembly mnemonics.
• Memory & Executable Generation: Managed low-level memory allocation and binary formatting.
  • Developed custom memory mappers and linkers (memory.py, linker.py) to handle section addressing (.data, .text) and label resolution.
  • Implemented an ELF format generator (elf.py) to compile the processed assembly directly into a standalone, executable .elf binary (file.elf).
• Graphical User Interface: Wrapped the assembler in a user-friendly graphical interface utilizing Python's tkinter and ttkbootstrap, allowing users to visually load, parse, and compile assembly code.

Veri Madenciliği (Data Mining)

This course focused on the entire data science lifecycle, from raw data extraction to predictive modeling. The core assignment was a Laptop Price Segmentation and Multi-Class Classification Project. Key accomplishments include:

• Feature Engineering & Preprocessing: Cleaned and transformed a raw laptop dataset using Python (pandas, re).
  • Utilized Regular Expressions (Regex) to extract hidden numerical data from messy strings, such as parsing screen resolutions to calculate Pixel Per Inch (PPI), and extracting exact GB/TB capacities from mixed memory descriptions (SSD, HDD, Flash).
  • Engineered a target variable by segmenting continuous prices into four distinct classes (Budget, Mid, High-Performance, Premium).
• Exploratory Data Analysis (EDA): Conducted statistical analyses and visualized distributions using matplotlib and seaborn, including log transformations for price normalization and correlation heatmaps.
• Machine Learning & Evaluation: Built and evaluated multiple classification models using scikit-learn.
  • Trained Logistic Regression, Decision Trees, and Random Forest classifiers, utilizing StandardScaler for normalization and StratifiedKFold for cross-validation.
  • Evaluated model performance through rigorous metrics including Macro F1-Scores, plotted Confusion Matrices, and extracted Feature Importance rankings to determine the most influential hardware specifications.

Veri Yapıları (Data Structures)

This course bridged algorithmic logic with memory management through practical C++ applications. The capstone project was an automated Maze Solver Game (LabirentOyunu). Key accomplishments include:

• Algorithmic Pathfinding: Implemented a classic Depth-First Search (DFS) style algorithm utilizing a Stack data structure to navigate a text-based maze.
  • The algorithm dynamically searches for valid moves (up, down, left, right), pushing each step onto the Stack. Upon hitting a dead end, it utilizes the pop() operation to backtrack through memory until a new valid path to the exit is found.
• Data Parsing & Matrix Manipulation: Parsed raw .txt map files into 2D array matrices, tracking the Start (B) and Exit (C) coordinates, and dynamically updating the matrix state as the algorithm progressed.
• Console Animation & Build Systems: Developed a real-time, animated terminal GUI.
  • Utilized the windows.h API to colorize the terminal, clear the screen dynamically without flickering, and implement sleep delays to visually animate the character's pathfinding progress.
  • Structured the project professionally (separating src, include, bin) and engineered a custom Makefile to handle compilation.

Veritabanı Yönetim Sistemleri (Database Management Systems)

This course covered the theory and practical application of Relational Database Management Systems (RDBMS). The primary project was designing and implementing a robust database architecture to model the Turkish Election System. Key accomplishments include:

• Relational Schema Design: Architected a complex relational database using SQL Server (T-SQL) and visualized it through SQL Server Management Studio (SSMS) Database Diagrams.
  • Designed normalized tables to represent Elections, Electoral Regions (Districts/Cities), Political Parties, Ballot Boxes, Candidates, and Voters.
• Data Integrity & Constraints: Engineered strict relational integrity using SQL constraints.
  • Implemented Primary Keys (with IDENTITY auto-incrementing) and complex Foreign Key relationships (e.g., tying individual Votes to specific Voters, Candidates, Ballot Boxes, and Election instances) to ensure accurate and tamper-proof data tracking.

Yapay Zekanın İlkeleri (Principles of Artificial Intelligence)

This course delved into the core algorithms driving modern Artificial Intelligence. The capstone project was an Object-Oriented Python application that trains an AI agent to flawlessly play Tic-Tac-Toe using Reinforcement Learning. Key accomplishments include:

• Q-Learning Algorithm Implementation: Built a complete Q-Learning model from scratch without relying on external machine learning libraries.
  • Formulated the state-action pairs (Q-table) and utilized the Bellman Equation to dynamically update Q-values based on custom reward signals (Win: +10, Loss: -10, Draw: 0).
• Exploration vs. Exploitation: Engineered a dynamic epsilon threshold to manage the agent's learning curve.
  • Successfully trained the AI by having it play 10,000 simulated games against itself with a high exploration rate to discover optimal strategies, before locking the epsilon to zero (pure exploitation) for matches against human players.
• Game State Management: Designed a robust Object-Oriented game engine (TicTacToe class) to handle turn logic, mathematically calculate win/draw conditions across all matrix axes, and interface with human console input.

Yapay Öğrenmenin Temelleri (Fundamentals of Machine Learning)

This course explored the application of machine learning algorithms to solve complex real-world optimization problems. The primary project was a Drone Logistics and Supply Distribution Optimizer. Key accomplishments include:

• Geospatial Clustering: Extracted and processed supply coordinate data from Excel using pandas.
  • Utilized scikit-learn to apply Agglomerative Clustering (employing Euclidean metrics and Ward linkage) to systematically group 45 supply points into 15 optimized delivery zones.
• Routing & Pathfinding: Implemented Dijkstra's Algorithm utilizing a min-heap structure to calculate the absolute shortest delivery path within each cluster, minimizing drone flight distances from the central depot.
• Resource Simulation: Developed a dynamic payload management system to simulate drone flights.
  • The algorithm actively tracks capacities (max 30 units), recalculates proportional payloads when zone needs exceed drone limits, and autonomously programs return trips to the depot to fulfill unmet supply nodes.

Yazılım Mühendisliği (Software Engineering)

This course emphasized the complete software development lifecycle, focusing on scalable architecture and clean code practices. The capstone project was the development of Song-to-Anki-Deck, a full-stack Python web application that dynamically generates language learning flashcards (Anki decks) from song lyrics.

🔗 View the complete project repository on GitHub

• Full-Stack MVC Architecture: Architected the application using the Model-View-Controller pattern, cleanly separating backend business logic (services/, models/, controllers/) from frontend rendering (templates/, static/).
• API & LLM Integration: Engineered data pipelines to fetch live lyrics via public APIs, subsequently passing the data through a Large Language Model (Google Gemini API) to autonomously generate translated, context-aware flashcards.
• Professional Engineering Practices: Applied industry-standard development workflows.
  • Managed dependencies and isolated environments using requirements.txt and venv.
  • Implemented secure credential management via .env files and structured application tracing via logging_config.py.
  • Enforced code reliability by integrating a comprehensive testing suite utilizing pytest.