Software Development Portfolio
Software Development
Portfolio
PROJECTS
This project demonstrates how to efficiently copy files using low-level stream operations in C#. Instead of relying on built-in convenience methods, the tool reads and writes file data in buffered chunks using FileStream, emphasizing performance, memory efficiency, and proper resource management. The project was built to deepen understanding of how file I/O works under the hood in .NET.
This project focuses on efficiently processing large text files by reading data incrementally rather than loading entire files into memory. Using a lazy-loading approach with StreamReader, the tool reads files line by line, making it suitable for log files, exports, or any high-volume text data where memory usage and performance are critical considerations.
This project introduces a reusable file analysis component that extracts meaningful statistics from text files, including line counts, word counts, and the most frequently occurring words. Designed with reusability and clean object-oriented principles in mind, the FileAnalyzer class can be integrated into other applications that require text analysis or reporting functionality.
This project implements a lightweight, reusable logging utility that writes timestamped log messages to a file with configurable log levels. The Logger class is designed to support basic application diagnostics and auditing while emphasizing safe file access and reusability across multiple projects.
This project converts XML data into JSON through a reusable conversion component. It focuses on transforming hierarchical XML structures into a JSON-friendly object model, then serializing the result into JSON. The goal is to build a clean, portable utility that can be reused in real-world integrations where legacy XML data needs to be consumed by modern JSON-based systems.
This project implements a lightweight ETL pipeline that imports structured data from a CSV file into a relational database using SQLite. The tool focuses on reliably ingesting external data, mapping it to a defined schema, and persisting it in a database while handling validation, performance, and error scenarios common in real-world data workflows.
This project provides a flexible utility for restructuring CSV files by allowing users to define a custom column order and optionally rename columns. The tool is designed to support real-world data normalization scenarios where incoming CSV formats vary between sources but must conform to a standardized schema for downstream processing or import.
This project focuses on cleaning structured data by identifying and removing duplicate records from a CSV file. The tool supports configurable deduplication logic, allowing duplicates to be detected based on full-row matches or selected key columns. It is designed to improve data quality prior to downstream analysis, import, or reporting.
This project converts Excel spreadsheets (XLSX) into CSV files, enabling easier ingestion into databases, data pipelines, and downstream tooling. It focuses on reliably extracting tabular data from Excel workbooks and normalizing it into a flat, portable CSV format commonly used in data processing workflows.
This project implements a text-search utility designed to scan large text files for user-defined keywords or patterns and extract matching lines. It is well-suited for use cases such as log analysis, diagnostics, and ad hoc data investigation where targeted information needs to be surfaced quickly from high-volume text data.
This project implements a simple but robust API client that retrieves data from a public REST API and persists the response locally. It focuses on making reliable HTTP requests, parsing JSON responses into usable data structures, and handling common network and failure scenarios encountered when integrating with external services.
This project automates routine file maintenance by identifying and removing or archiving files that exceed a configurable age threshold. Designed for hands-off operation, the tool helps keep directories clean and manageable while reinforcing safe file system interaction and basic automation patterns.
