📞 Get In Touch
I am a software engineer with a passion for building robust, efficient, and well-designed systems. My work spans the full spectrum of technology, from low-level systems programming and operating systems fundamentals in C and Assembly to high-level, AI-driven applications and full-stack web services. This portfolio is a curated collection of my projects, reflecting a commitment to understanding computer science from first principles and applying that knowledge to solve complex problems. I believe that a deep comprehension of how memory is managed, how schedulers operate, and how databases process queries is essential for creating truly exceptional software at any level of the stack.
My approach is grounded in modern software engineering practices, including rigorous testing, containerization for reproducible environments, and a focus on creating clean, maintainable code. Whether it's implementing a custom memory allocator, architecting a multi-modal AI application, or deploying a full-stack web service, my goal is to deliver solutions that are not only functional but also thoughtfully engineered.
| Languages & Runtimes | Frontend | Backend & APIs | Data & ML | Databases & Storage | DevOps & Cloud |
|---|---|---|---|---|---|
           |
              |
        |
              |
      |
          |
| IDEs & Editors | Version Control & PM | OS & Virtualization | Networking & Security | Testing & QA | Build · Package · Misc |
|---|---|---|---|---|---|
         |
     |
      |
        |
     |
                   |
This section highlights a few key projects that represent the breadth and depth of my skills, from foundational systems engineering to deployed, user-facing applications.
RoboDoc is a multi-modal AI application designed to explore the potential of machine learning in healthcare decision support. Built with Python and Streamlit, it integrates three distinct AI modules into a single, interactive platform. This project showcases the ability to build and integrate complex ML models into a user-friendly application, with a strong emphasis on model explainability, a critical component for trust in AI systems.
-
SBERT-Powered Clinical Q&A: A sophisticated chatbot that uses Sentence-BERT embeddings to understand and answer clinical questions based on a built-in medical knowledge base.
-
Biomarker-Based Disease Classifier: A classic machine learning model that predicts the likelihood of a disease based on patient biomarker data.
-
Explainable Survival Predictor: A model that predicts patient survival outcomes and, crucially, uses SHAP (SHapley Additive exPlanations) to provide visual explanations of which factors contributed most to its prediction.
-
Technologies: Python, Streamlit, Scikit-learn, SBERT, SHAP, Pandas.
This project is a C-based simulation of a Memory Management Unit (MMU), a fundamental hardware component in modern computers. By implementing this from scratch, I explored the core mechanics of virtual memory, which underpins how operating systems provide memory safety and efficiency. VirtuMMU translates virtual addresses to physical addresses, simulates page table lookups, and enforces memory protection. This work demonstrates a deep, practical understanding of computer architecture and low-level operating system design.
-
Core Functionality: Simulates virtual-to-physical address translation using a hierarchical page table structure.
-
Memory Protection: Implements read, write, and execute permissions at the page level, a cornerstone of modern OS security.
-
First-Principles Approach: Built entirely in C with no external libraries, focusing on the fundamental algorithms and data structures involved in memory management.
-
Technologies: C, Makefiles.
Culinary Otter is a deployed, server-rendered Node.js web application for discovering and managing recipes. This project demonstrates the ability to build a complete, user-facing product, integrating multiple third-party APIs and managing a persistent relational database. It features a full authentication system, session management, and an operational mindset with features like automated daily data resets. The architecture is a classic server-side rendering (SSR) model, which is highly effective for content-driven sites.
-
Full-Stack Architecture: Built with Node.js and Express, serving dynamic HTML pages templated with EJS and backed by a MySQL database.
-
Multi-API Integration: Enriches user experience by fetching recipe data from the Spoonacular API and real-time pricing information from the Kroger API.
-
User & Session Management: Includes secure user registration, login, and session persistence, allowing users to save and manage their favorite recipes.
-
Technologies: Node.js, Express, EJS, MySQL, Docker, Spoonacular API, Kroger API.
Live: https://culinary-otter.r-siddiq.tech • Source: https://github.com/r-siddiq/culinary-otter
This repository is not just a collection of algorithm solutions but a rigorously engineered software portfolio. It contains modern C++17 implementations of a wide range of classic data structures and algorithms, all organized within a professional CMake build system and validated with CTest unit tests. This project showcases a commitment to algorithmic excellence and high-quality software engineering practices, including modularity, testing, and clean code.
-
Comprehensive Coverage: Includes implementations of graphs (adjacency lists/matrices), hash tables, heaps, various sorting algorithms, dynamic programming solutions, and topological sorting.
-
Modern C++: Utilizes C++17 features for clean, efficient, and safe code.
-
Professional Tooling: Employs CMake for a cross-platform build system and CTest for a structured unit testing framework, demonstrating a professional development workflow.
-
Technologies: C++, C++17, CMake, CTest.
My work in AI begins with a strong foundation in data science principles and classic machine learning, progressing to the development of specialized, application-driven AI systems.
- Machine Learning & Data Science Monorepo: A structured collection of Jupyter Notebooks that serves as my personal knowledge base. It covers everything from data wrangling with NumPy and pandas to model building and evaluation with scikit-learn, emphasizing reproducible and well-documented practices.
https://github.com/r-siddiq/Machine-Learning-And-Data-Science
- RoboDoc: An AI-powered medical decision-support application featuring an SBERT chatbot, a disease classifier, and a survival predictor with SHAP explainability.
- Onco-Logic (Fork): A fork of a comprehensive, multi-modal decision-support ecosystem for oncology. My contributions and exploration within this project focus on integrating fragmented patient data and leveraging advanced AI/ML to provide holistic patient views for clinicians.
I have experience building both server-rendered and client-side web applications, with a focus on creating robust backends and interactive user experiences. Many of these projects are deployed and include operational considerations beyond simple development, such as health-check endpoints and automated data management scripts.[1]
- Culinary Otter: A server-rendered Node.js/Express recipe app with MySQL, multi-API integration, and user authentication.
Live: https://culinary-otter.r-siddiq.tech • Source: https://github.com/r-siddiq/culinary-otter
- Inspira Find: A Node.js/Express web app for finding inspirational quotes, featuring a multi-criteria search portal for users and a full CRUD management portal for admins. It demonstrates a clear separation of user and admin roles and interfaces within a single application.
Live: https://inspira-find.r-siddiq.tech • Source: https://github.com/r-siddiq/inspira-find
- Learning Machine Learning: A dynamic SSR web application built with Node.js and Express that serves interactive content about machine learning. It uniquely integrates with the Google Gemini AI API to fetch and display on-demand, AI-generated content, demonstrating a powerful combination of server-side rendering and external AI services.
Live: https://learning-machine-learning.r-siddiq.tech • Source: https://github.com/r-siddiq/Learning-Machine-Learning
- Express Solar System: A multi-page Express.js and EJS website that showcases routed content, templating with partials, and consumption of external APIs (Unsplash and NASA APOD) to create a content-rich, server-rendered experience.
Live: https://express-solar-system.r-siddiq.tech • Source: https://github.com/r-siddiq/Express-Solar-System
- Responsive Sign-Up Page: A clean, responsive sign-up form built with HTML, CSS, JavaScript, and Bootstrap. It includes robust client-side validation, an API call to check for username availability, and a secure password suggestion feature.
Live: https://r-siddiq.tech/Sign-Up-Page/ • Source: https://github.com/r-siddiq/Sign-Up-Page
- Quake Finder: A static front-end web app that visualizes earthquake data from the USGS API on an interactive Google Map. This project highlights asynchronous API calls and dynamic DOM manipulation in a pure JavaScript application.
Live: https://r-siddiq.tech/Quake-Finder/ • Source: https://github.com/r-siddiq/Quake-Finder
- Guess It: A minimal, frontend-only number guessing game built with vanilla HTML, CSS, and JS. It serves as a great example of basic DOM manipulation and event handling.
Live: https://r-siddiq.tech/Guess-It/ • Source: https://github.com/r-siddiq/Guess-It
- Pop Quiz: A lightweight quiz application that uses various input types and provides immediate, color-coded feedback. It demonstrates state management using
localStorageto track user attempts.Live: https://r-siddiq.tech/Pop-Quiz/ • Source: https://github.com/r-siddiq/Pop-Quiz
- ML Info Frontend: A multi-page static site built with only HTML5 and CSS3 that introduces core machine learning concepts. It demonstrates content organization and styling for technical topics without relying on frameworks or build tools.
Live: https://r-siddiq.tech/ML-Info-Frontend/ • Source: https://github.com/r-siddiq/ML-Info-Frontend
This collection of projects demonstrates a firm grasp of the low-level concepts that power all modern software. Building these systems from the ground up in C provides an invaluable perspective on performance, concurrency, and resource management.
- VirtuMMU: A C-based simulation of a Memory Management Unit, modeling virtual-to-physical address translation and memory protection.
- Mallocator: A custom memory allocator implemented in C, replacing the standard
malloc/free. It manages a memory arena with block splitting and coalescing to minimize fragmentation, showcasing a deep understanding of heap memory management. - ThreadNexus: A multithreaded TCP server in C that manages a shared database. It explores concurrency primitives (pthreads), synchronization with mutexes, and the design of thread-safe data structures, complete with unit tests to validate concurrent behavior.
- PULSE (CPU Scheduler Simulator): A C simulator for classic CPU scheduling policies like round-robin and FIFO. It uses a pluggable architecture to model both preemptive and non-preemptive scheduling, reinforcing core OS concepts.
- Strings and Ciphers: A modern C11 codebase implementing string manipulation utilities and classic ciphers. It demonstrates best practices in C programming, including the use of Makefiles for automated builds and the Criterion framework for unit testing.
My experience with databases extends from application-level design and querying to the rare and valuable work of implementing database engines from first principles. This dual perspective provides a unique advantage in designing and optimizing data-intensive applications.
- BitMatrix (Java RDBMS): A mini relational database management system built in Java. It supports schema definition, data insertion, and querying for both in-memory and file-backed tables, including basic indexing and query optimization.
- NatJoin (Java in-memory DB): A simple in-memory database system in Java with a focus on implementing a natural join algorithm from scratch, illustrating how core relational operations work at a low level.
- HeapQuery (Java in-memory DB): An in-memory database system that supports data manipulation and boolean query conditions, with an emphasis on using in-memory data structures and serialization for persistence.
- SchemaCraft: A lightweight Java toolkit for defining schemas, creating typed tables, and performing relational operations. It uses Java NIO (
ByteBuffer) for low-level data management and is thoroughly tested with JUnit.
- DB Solutions (SQL Portfolio): A collection of SQL scripts demonstrating proficiency in relational database design, including schema creation, complex queries, and data modeling in MySQL.
- Prescription Webapp (NoSQL): A Spring Boot web application using MongoDB to manage healthcare data. It demonstrates CRUD operations and web UI development in a NoSQL, document-store context.
- Prescription Webapp (JDBC): A Spring MVC web app backed by a relational database via traditional JDBC. It highlights a multi-role workflow and secure data handling in a classic MVC architecture.
- LibraTrack: A Java/Gradle project modeling a library system. It demonstrates object-oriented design for a persistent system, using file handling for storage and JUnit for reliability testing.
I have experience building native Android applications using Java and modern Android Jetpack components, following best practices like the MVVM architectural pattern.
- GymLog: An Android workout tracker built with Java following the MVVM architecture. It uses Room (SQLite) for local persistence, LiveData for reactive UI updates, and RecyclerView for displaying lists of user-specific exercise logs.
- Pill Hub: A native Android pharmacy management app built with Java and Room. It demonstrates a multi-user system where patients can manage their prescriptions and admins can manage the drug inventory, all within a clean MVC-like structure.
- C↔F Converter: A simple native Android app for temperature conversion. It demonstrates fundamental concepts like navigation between Activities using Intents and UI management with ViewBinding.
- Android LifeCycles: A demo app written in Java to illustrate the Android Activity lifecycle. It logs all lifecycle callbacks (
onCreate,onStart, etc.) and shows how to persist UI state across configuration changes like screen rotations.
These projects focus on socket programming, concurrency, and network security. A recurring theme is the use of Docker and Mininet to create reproducible and realistic environments for testing network applications.
- SecureNexusNetwork: A multi-client chat service written in Python that features TLS encryption for secure communication. It offers two deployment modes: a simple Docker Compose setup and a more advanced Mininet-based virtual network simulation for in-depth analysis.
- Thread Chat: A Python TCP chat service focused on threading and automation. It is fully containerized with Docker and includes interactive demos, showcasing socket programming, concurrency, and health checks.
- Packet Pulse: A Python-based UDP "pinger" and heartbeat monitor. It simulates round-trip time measurements, packet loss, and heartbeat messages, demonstrating low-level UDP socket programming.
- Client-Server Socket Demo: A Python UDP client/server demonstration provided in both Dockerized and Mininet-based versions, highlighting message passing and techniques for testing network programs in isolated environments.
This collection of Java projects focuses on core object-oriented programming principles, design patterns, and algorithmic thinking. Each project is well-tested with JUnit to ensure correctness.
- Battle Strategy (Design Pattern): A Java project demonstrating the Strategy Design Pattern by implementing interchangeable "battle behaviors" for game characters. It showcases clean, extensible OOP design by separating algorithms from the objects that use them.
- Markov Text Generation: A Java program that generates new text based on the statistical properties of an input file using Markov chains. It highlights the use of data structures (like HashMaps) to build transition tables and demonstrates probabilistic algorithms.
- Trooper Maker: A Java project that models a Star Wars character hierarchy, demonstrating core OOP principles like inheritance, encapsulation, and polymorphism. It includes proper
equals()/hashCode()overrides and JUnit tests. - Histogram (Letter Frequency): A Java program that reads text files and builds letter-frequency histograms. It demonstrates file I/O, exception handling, and the use of collections, with thorough JUnit 5 tests.
A strong house is built on a solid foundation. These repositories represent a methodical and deliberate approach to mastering the fundamentals of programming and computer science theory, from the lowest level of abstraction up.
- Assembly Language Basics: A repository of x86 assembly programs demonstrating low-level concepts like procedures, stack frames, branching, array manipulation, and making system calls for I/O.
- Discrete Structures (C++): A collection of C++ programs that implement concepts from discrete mathematics, such as propositional logic evaluators, set operations, permutations, and recursion. These exercises bridge the gap between mathematical theory and executable code.
- Data Structures & Algorithms Portfolio (C++): A modern C++17 portfolio of classic data structures and algorithms, built and tested with CMake/CTest.
- C++ Foundations: A set of introductory C++ console programs covering vectors, strings, dynamic memory, linked lists, and basic sorting, all built with CMake.
- Java Foundations: A series of fundamental Java exercises focusing on console I/O, arrays, exceptions, and basic OOP principles, reinforcing core language concepts.
- Python Foundations: A beginner-friendly collection of Python programs covering user input, functions, loops, and error handling, including simple games and turtle graphics demos.