Caleb Stewart

CSCD 210: Programming Principles I

Studied fundamental programming concepts including data types, algorithms, and program design, with a focus on writing, debugging, and analyzing computer programs.

MATH 231: Linear Algebra

Covered topics in vector geometry, systems of linear equations, matrix algebra, determinants, vector spaces, linear transformations, eigenvalues, and eigenvectors, with practical applications.

CSCD 211: Programming Principles II

Studied advanced programming concepts building on Programming Principles I, including recursion, polymorphism, inheritance, and data structures such as linked lists and array lists.

MATH 300: Discrete Mathematics

Covered foundational and implementation topics in mathematics relevant to computer science, including logic, induction, recursion, set theory, modular arithmetic, graph theory, and matrix operations (e.g., systems of linear equations and graph representations).

CSCD 212: Object-Oriented Programming with Design Patterns

Studied advanced object-oriented principles and design patterns, including UML class diagrams, unit testing, and code versioning, with hands-on programming projects.

Relevant Projects:

• Implemented Object-Oriented Design Patterns, including Strategy, Factory, Builder, Observer, Prototype, and Facade, to build and customize a simulated cruise package manager.
• Delivered a fully functional simulation with multiple customization options, improving my understanding of design patterns and their practical applications.

MATH 380: Probability and Statistics

Studied empirical and theoretical frequency distributions, random variables (discrete and continuous), binomial and normal distributions, descriptive statistics (measures of location, spread, and association), and an introduction to inferential statistics (confidence intervals and hypothesis testing).

CSCD 240: C and UNIX Programming

Studied UNIX programming tools and the C language, with a focus on interactive shells, file system structure, system programming techniques, and data structures such as arrays and linked lists, including their implementation and use in real-world applications.

CSCD 327: Relational Database Systems

Studied the fundamentals of relational database systems, focusing on data manipulation language (DML), data definition language (DDL), and relational models. Topics included SQL, relational algebra, and entity-relationship modeling, with an emphasis on their practical application in database design and management.

Relevant Projects:

• Embedded SQL queries into Java using JDBC to create a standalone program, demonstrating the practical integration of databases with Java applications.

CSCD 303: Computer and Information Security

Studied the fundamentals of computing security, covering threat types, malware, virus protection, and methods for securing computers and information. Gained hands-on experience using various security tools to apply theoretical concepts in practical scenarios.

CSCD 260: Architecture and Organization

Studied the fundamentals of digital computer design and microcomputer systems, exploring number systems, Boolean algebra, digital circuits, and assembly language programming, with a focus on how these concepts apply to modern computing systems.

Relevant Project:

• Developed a simulated pixel using the Tiva C evaluation board, utilizing 7-segment displays, potentiometers with ADC, and multiple buttons to represent different pixel colors.
• Leveraged hardware components to create a hands-on simulation, demonstrating fundamental concepts in microcontroller systems, hardware integration, and digital circuit design.

CSCD 300: Data Structures

Studied fundamental abstract concepts of data structures and their implementation, with an emphasis on linked lists, stacks, queues, hashing, recursion, complexity analysis of algorithms, and binary search trees.

Relevant Projects:

• Built and implemented multiple types of data structures, including LinkedLists, Stacks, Queues, HashTables, and Binary Trees.
• Developed and optimized various sorting and traversal algorithms, improving efficiency and understanding of algorithmic design.

CSCD 470: 3D Computer Graphics Principles

Studied basic and advanced theoretical concepts in 3D computer graphics using OpenGL and C, illustrated through 3D rendering software to understand practical applications.

Relevant Projects:

• Calculated per-vertex normals and applied different wave functions to update 3D models.
• Built various primitive shapes such as circles, tori, tetrahedrons, cylinders, and other 3D objects.
• Worked with different shading techniques, including Toon shading, Gouraud shading, and Phong shading, to create realistic visual effects.
• Applied texture mappings and manipulated normal-mapped objects to enhance visual realism.
• Implemented geometry shaders and tessellation shaders to improve model details and rendering quality.
• Utilized normal mapping to enhance surface detail and depth perception in rendered objects.

CSCD 320: Algorithms

Studied advanced data structures and algorithms, focusing on algorithmic strategies such as dynamic programming, greedy algorithms, and non-linear data structures like trees and graphs, with an emphasis on optimizing problem-solving approaches and improving computational efficiency.

Relevant Projects:

• Implemented Priority Queues and worked with graph algorithms such as Bellman-Ford and Dijkstra for shortest path calculations.
• Explored and implemented multiple tree structures, including BTrees and Red-Black Trees, for efficient data storage and retrieval.
• Solved dynamic programming and greedy problems, applying these strategies to optimize solutions for various computational challenges.

CSCD 330: Computer Networks

Studied fundamental concepts, protocols, and programming skills for computer networks, including telecommunication media, Internet protocols, and network layers, with a focus on practical networking and security practices.

Relevant Projects:

• Developed web-based API calls to retrieve information, wrote an API server using the Flask library.
• Built a TCP client similar to curl and wget, capable of retrieving complete webpages via HTTP.
• Utilized the Python library Scapy to build packets, complete a three-way handshake, and send a valid GET request.
• Created a custom TCP traceroute tool using Scapy to trace the route of network packets.
• Created and networked four virtual machines, one acting as a router with three users, simulating a network setup.

CSCD 350: Software Development Principles

Studied the principles and tools essential for designing, analyzing, and maintaining large-scale software systems, covering key areas such as project management, software verification, testing techniques, and strategies for ensuring system reliability and performance throughout the software development lifecycle.

Relevant Projects:

• Developed ParkSmart, a parking management system in an agile environment, working on both front-end and back-end development.
• Implemented key system components using Python Flask, SQLAlchemy, and JavaScript, ensuring a scalable solution for managing hundreds of parking lots dynamically.
• Created and designed documentation for each step of the project.

CSCD 377: Introductory Computer Graphics

Studied the concepts and techniques of 3D modeling and animation using OpenGL Shading Language (GLSL), focusing on the creation of primitive building blocks and understanding the underlying principles of computer graphics, with hands-on experience in rendering and manipulating 3D models.

CSCD 340: Operating Systems

Studied the design and modeling of operating systems, covering CPU virtualization, memory virtualization, concurrency, file systems, and data storage, with an emphasis on how these components interact to optimize system performance and resource management.

Relevant Projects:

• Worked with a team to build a functioning operating system using Intel x86 assembly and C, focusing on memory management.
• Implemented the memory management unit (MMU), including the heap and paging systems to manage memory efficiently.

CSCD 439: Flight Simulation

Studied game development with a focus on multiplayer environments, covering aircraft, avionics, terrain, weather, navigation, and cultural features. Explored real-world applications like training simulations and entertainment, including systems like Microsoft Flight Simulator and full-motion simulators. Examined software/hardware architecture and graphics.

Relevant Projects:

• Developed a basic flight control system where the airplane moves based on its facing direction, with control over pitch, yaw, and speed.
• Developed a procedural terrain generation system using guided random techniques, including mesh creation, elevation mapping, and noise addition, and integrated simple cultural features like human-made objects onto the terrain.
• Implemented both low-level control systems (elevator, aileron, rudder, power, and flaps) for direct manipulation of aircraft components, and medium-level control systems (pitch, roll, and speed) for achieving stable flight states, making the airplane simulation more realistic and engaging.
• Demonstrated basic navigation by programming the airplane to fly between predefined waypoints, where air traffic control (ATC) issues explicit and implicit commands to perform complex maneuvers based on the aircraft's current state.

CSCD 430: Big Data Analytics

Studied the fundamental concepts and practices of big data computing, focusing on the challenges that arise when data size exceeds the capacity of traditional analytics systems. Explored tools and technologies such as HDFS, MapReduce, and Spark for processing large datasets. The course covered various techniques for analyzing both structured and unstructured data, including tasks like finding similar items, mining data streams, and link analysis. It also examined methods for mining graphs and implementing recommendation systems, providing hands-on experience in applying analytics algorithms to manage, mine, and analyze big data across a variety of real-world applications.

CSCD 484: Machine Learning

Studied various methods for learning and recognizing patterns in data, focusing on supervised learning models such as the perceptron learning algorithm, linear regression and its nonlinear transformation, logistic regression, neural networks, and model ensembles. The course emphasized understanding the underlying mechanics of these models, explaining how and why they are effective for pattern recognition.

Relevant Projects:

• Developed a perceptron model to classify binary data.
• Implemented a linear regression model for predictive analysis on continuous data.
• Built a logistic regression model to classify data into two categories.
• Created a neural network to distinguish handwritten digits (MNIST dataset) using forward feeding and backpropagation. The network was trained using stochastic gradient descent, adjusting the weights through backpropagation to minimize the error and improve prediction accuracy on the validation dataset.

CSCD 488: Senior Project

Participated in the first part of a two-quarter project sequence, applying computer science principles to develop a specified project. Utilized appropriate tools, systems, and management skills to support project development.

Project Details:

• Developed a computer vision-based solution designed to help brands, marketing teams, and event organizers measure brand visibility in visual media.
• Leveraged machine learning and image recognition techniques to analyze video footage, detect and track specific logos, and measure their screen time.
• Created a web-based dashboard where users can upload videos and logo images for analysis.
• Generated targeted analytics focused on brand visibility to help marketers evaluate ROI, optimize strategies, and provide actionable sponsorship insights.
• Designed the solution to be versatile across different media forms (sports, concerts, dashcam footage) and accessible to users without extensive technical skills.

CSCD 490: Senior Capstone Project

Comprehensive capstone experience involving the design, development, and deployment of a substantial software engineering project over two academic quarters. Applied advanced computer science concepts and methodologies to solve real-world problems through collaborative team-based development. The course emphasized full-stack software engineering practices, including requirements analysis, implementation across multiple technologies, testing strategies, and deployment considerations. Gained experience with project management methodologies, and version control systems.

Focused on integrating knowledge from multiple computer science disciplines including machine learning, computer vision, software engineering, and user interface design. The capstone experience required us to navigate complex technical challenges, make architectural decisions, adapt to changing requirements, and deliver a production-quality software solution. Emphasis was placed on both technical excellence and practical considerations such as performance optimization, scalability, user experience design, and cross-platform compatibility.

Capstone Project:

• Trademark Analysis & Identification Tool (TRAIT): Collaborated in a three-person team to develop a sophisticated computer vision desktop application for automated logo detection and brand visibility analysis in images and videos. Implemented a multi-model machine learning pipeline using YOLOv8 for object detection trained on the LogoDet-3k dataset (200,000+ images, 3,000 categories), achieving 81.02% precision and 76.73% recall. Designed and implemented a custom logo matching system utilizing multiple embedding models (BEiT, CLIP, ResNet) with a voting mechanism across cosine similarity and Euclidean distance metrics to significantly reduce false positives. Integrated FAISS vector database for efficient similarity search and caching of previously identified logos. Built a full-stack application with React.js/Electron.js frontend and Python Flask backend, containerized with Docker for cross-platform deployment. Successfully pivoted from web-based to desktop application architecture to overcome computational limitations and deliver optimal performance for marketing teams, brand owners, and event organizers.
  
  Technologies: YOLOv8, CLIP, BEiT, ResNet, FAISS, React.js, Electron.js, Python Flask, Docker
  Main Repository Backend Frontend

CSCD 485: Deep Learning

Studied various neural network-based deep machine learning models, including Convolutional Networks, Recurrent Networks and LSTM variants, and attention-based Transformers. Explored practical strategies for effective model training such as Dropout and batch/layer normalization, with emphasis on real-world applications and implementation.

Relevant Projects:

• Implemented Convolutional Neural Networks (CNNs) for image classification tasks, demonstrating proficiency in computer vision applications.
• Built and trained Recurrent Neural Networks (RNNs) and Long Short-Term Memory (LSTM) networks for sequential data processing and time series analysis.
• Applied advanced training techniques including dropout regularization, batch normalization, and layer normalization to improve model performance and prevent overfitting.
• Completed comprehensive programming assignments that required implementing these models from scratch, deepening understanding of the underlying mathematical concepts and algorithmic details.
• Narrative Quest Generation: Collaborated with a teammate to develop a sophisticated text-based adventure game powered by PygmalionAI-12B, a fine-tuned Large Language Model optimized for fantasy and roleplaying scenarios. Built the application using Python's Textual framework as a Terminal User Interface (TUI) and deployed it on Azure cloud infrastructure with GPU acceleration for optimal performance. Implemented advanced prompt engineering techniques to guide the LLM's behavior as a dungeon master, incorporating context retrieval through FAISS vector databases to maintain story consistency and character continuity. Utilized model quantization (GGUF format) to optimize the 25GB model down to 12GB for efficient GPU memory usage, and integrated Ollama for seamless model serving. The project demonstrates practical application of deep learning in interactive entertainment, combining infrastructure-as-code practices (Terraform), cloud computing, and natural language processing to create an immersive gaming experience with infinite narrative possibilities.
  Technologies: Python, Textual, Azure, Terraform, Ollama, FAISS, Hugging Face, Model Quantization
  View Project on GitHub

CSCD 477: Virtual Reality with Computer Graphics and Game Engines

Comprehensive introduction to virtual reality (VR) concepts through the integration of computer graphics theory and practical game engine implementation. The course emphasized hands-on development using industry-standard game engines as platforms for graphics programming, bridging theoretical computer graphics knowledge with real-world VR application development. Explored the technical foundations of immersive virtual environments, including spatial computing, rendering pipelines optimized for VR, and the unique challenges of maintaining consistent frame rates and minimizing motion sickness in virtual experiences.

Studied both unimodal and multimodal virtual environments, investigating how different sensory inputs (visual, auditory, haptic) can be combined to create compelling and believable virtual experiences. The curriculum also covered scientific visualization techniques within VR contexts. Gained experience with VR-specific programming paradigms, including spatial UI design, and 6-degrees-of-freedom interaction systems.