Syracuse University
đź“š Syracuse University Coursework
Welcome to my Syracuse University coursework page. I have utilized a variety of languages for my courses, but a majority of it is Python. All files can be found on my Github repository linked below the course.
Major Notes about Undergraduate work
Not all of my work is seen on github because I had my computer stolen. This is only a snippet of the work completed for my undergraduate degree. Many Assignments are missing and/or incomplete. For this reason, I will not be including executed code from homeworks or projects. I will only be including the projects that have been saved per class. Thank you for understanding.
CIS341 - Computer Organization & Programming Systems
Course Summary
In this class, I learned the foundational concepts behind how computers work at a low level. I started with digital logic—understanding how basic gates and circuits make decisions using binary. From there, I explored data types and how different kinds of information like integers, characters, and floating-point numbers are represented in binary form. I got hands-on with instruction set architecture, learning how processors understand and execute instructions.
We worked with assembly language, which gave me insight into how high-level code translates into machine instructions. I also learned how programs are constructed and how the CPU processes them step by step. The course covered the memory hierarchy too—how registers, cache, RAM, and storage work together to balance speed and capacity.
We discussed traps and interrupts, which taught me how the processor handles unexpected events or system calls. I learned about system privilege levels and basic security concepts that protect the OS and hardware. Finally, we went over input-output subsystems and how external devices communicate with the CPU.
Overall, this course gave me a much deeper understanding of what’s happening under the hood whenever I write or run a program.
CIS 352 - Programming Language: Theory & Practice
Course Summary
In this course, I’ve been learning how different programming language features work by building them myself using Racket, a functional programming language. Working with Racket has really helped me understand the fundamentals of how programming languages are designed and implemented.
I started by writing definitional interpreters—small interpreters that define how programs in a simple language should behave. These interpreters helped me understand how environments and stores work behind the scenes to manage variable bindings and mutable state. Racket’s support for recursive functions and pattern matching made it easier to express these ideas clearly and concisely.
As I explored scoping rules, I saw the difference between lexical and dynamic scoping, and how closures capture their environment. I also learned how to simulate imperative features, like assignment and sequencing, even in a language that’s primarily functional.
Throughout the course, I implemented features like modules, classes, and data encapsulation by designing custom structures and functions that mimic object-oriented behavior. This showed me how even object-oriented ideas can be modeled in a functional style.
Later on, I explored type systems, building simple static type checkers to catch type errors before a program runs. I also learned about polymorphism, and how generic functions can work with many types using parametric typing.
Overall, this course helped me understand not just what language features do, but how to actually implement them from scratch. Using Racket gave me a hands-on way to explore both functional and imperative paradigms, and gave me a much deeper appreciation for the structure of programming languages.
CIS 400 - Data Mining
Course Summary
In this course, I’ve been learning how to mine and analyze data from social media, specifically using the Twitter API. The focus has been on collecting real-time and historical Twitter data by writing scripts that interact with Twitter’s platform to “scalp” large amounts of relevant information.
I started by understanding how the Twitter API works — including authentication, rate limits, and the different endpoints available to access tweets, user information, and trends. Using programming languages like Python, I learned to write code that fetches tweets based on specific keywords, hashtags, locations, or user profiles.
Through this process, I gained hands-on experience with data collection techniques such as streaming and REST API calls, which helped me build datasets for further analysis. I also explored how to clean and preprocess the noisy and unstructured Twitter data, handling challenges like missing information, duplicate tweets, and slang or emojis.
The course taught me how to apply basic data mining methods to the collected data, including text analysis, sentiment analysis, and trend detection. By working on projects, I practiced building visualizations and dashboards that summarize the insights derived from the Twitter data.
Overall, this course gave me practical skills in using APIs for large-scale data gathering and the foundational knowledge to analyze social media data in meaningful ways.
CIS 400 - Evolutionary Machine Learning
Course Summary
In this course, I’ve been diving into evolutionary machine learning techniques, combining concepts from evolutionary algorithms with deep learning frameworks like PyTorch. The goal has been to understand how nature-inspired algorithms—like genetic algorithms, particle swarm optimization, and evolutionary strategies—can be used to optimize neural networks and solve complex problems.
I started by learning the basics of evolutionary algorithms, including how populations of candidate solutions evolve over generations through selection, crossover, and mutation. Then, I explored how to represent neural network parameters as genomes and apply these evolutionary operators to train models without relying solely on gradient-based methods.
Using PyTorch, I implemented various evolutionary algorithms from scratch and integrated them with deep learning models. This hands-on experience helped me understand the flexibility of PyTorch’s tensor operations and automatic differentiation while experimenting with alternative optimization strategies.
Throughout the course, I worked on projects that involved evolving neural network architectures and weights to improve performance on benchmark datasets. This approach allowed me to appreciate the balance between exploration and exploitation in search algorithms and how evolutionary methods can complement traditional machine learning techniques.
Overall, this course has expanded my toolkit for training machine learning models and deepened my understanding of how evolutionary computation can drive innovation in AI.
CIS 453 - Software Specification and Design
Course Summary
In this software engineering course, I learned the full cycle of how software is planned, designed, and developed in a structured way. We started by studying different software engineering process models, which helped me understand how projects can be managed using approaches like Waterfall and Agile. I got hands-on practice analyzing software requirements, both behavioral (how the software should act) and nonbehavioral (like performance or security needs). Our main planning style learned was waterfall method, which has since been outdated.
One of the most interesting parts was learning object-oriented analysis to break down complex systems using concepts like classes and interactions. We practiced writing up specification documents that clearly define what a software system should do, and I learned how crucial those documents are for keeping a project on track.
We also worked with UML (Unified Modeling Language) to visually design systems using use case diagrams, class diagrams, and sequence diagrams. That really helped me organize my thinking during the high-level design and software architecture phases.
Throughout the semester, we worked in teams to apply all these concepts in real projects. It gave me a better appreciation of how collaboration, planning, and good design principles come together in professional software development.
Overall, this class gave me a strong foundation in both the technical and collaborative aspects of building real-world software systems.
CIS 454 - Software Implementation
Course Summary
After laying the groundwork in CIS 453 by designing software systems and writing UML specifications, CIS 454 was all about bringing those designs to life through implementation and testing.
We started with detailed design work, breaking down high-level architecture into more granular components ready for coding. Then, using tools like Git and development environments like Visual Studio Code, we began implementing our software systems directly from our UML diagrams and specification documents.
Throughout the course, we used agile development methodologies, working in sprints, doing standups, and managing our tasks with tools like Trello or Jira. This iterative process helped us stay organized, adapt to feedback quickly, and work efficiently in teams—just like in real-world software engineering.
Testing was also a major focus. We practiced writing unit tests and performing integration testing to ensure each part of the software worked as expected. This gave me a much better understanding of the software development lifecycle, especially how important early and continuous testing is to building reliable applications.
Lastly, we explored topics of ethics and social responsibility, discussing how the software we build can impact users and society. It was a reminder that good engineering is about more than just code—it’s about thoughtful design, inclusive practices, and accountability.
By the end of CIS 454, I had taken a full software project from design to a working product, which was both challenging and extremely rewarding.
CIS 477 - Introduction to Analysis of Algorithms
Course Summary
In this course, I explored the mathematical modeling of computational problems and learned how to design efficient algorithms to solve them. We started with foundational concepts like searching and sorting algorithms, analyzing their time and space complexities. This gave me a strong understanding of how performance is affected by algorithmic choices.
I worked with data structures such as search trees, heaps, and hash tables, and used them to solve problems more efficiently. From there, we explored powerful algorithm design paradigms like divide-and-conquer, dynamic programming, and greedy algorithms—each offering different strategies for tackling complex tasks.
We also dove deep into graph algorithms, including breadth-first search, depth-first search, Dijkstra’s, and Kruskal’s algorithms, which taught me how to model and solve real-world problems involving networks and relationships.
One of the most fascinating parts of the course was studying Graph algorithms and understanding how math and algorithmic thinking conquer graph theory. Toward the end of the course, we touched on NP-completeness, which introduced me to the limits of computational feasibility and the significance of problems that don’t have known polynomial-time solutions.
Overall, this course sharpened my problem-solving skills and gave me a deeper appreciation for the power and limitations of algorithms in computing.
CSE 384 - Systems and Network Programming
Course Summary
In this course, I learned how to write and manage Unix-based systems and network software using shell scripting and the C programming language. One of the first skills I picked up was working with Makefiles, compilers, linkers, and debuggers, which helped me manage large projects with multiple source files more efficiently.
I got hands-on experience with system calls and dynamic memory allocation, deepening my understanding of how low-level programs interact with the operating system. Working with pointers and memory management in C taught me how to write more efficient and robust code while also helping me appreciate the complexity of systems-level programming.
We also covered concurrent and parallel programming, where I learned how to write code that could take advantage of multiple CPU cores or manage tasks simultaneously using processes and threads. These skills were essential for the network programming portion of the course, where I implemented client-server applications using sockets.
The course placed a strong emphasis on defensive programming techniques—anticipating failures and writing secure, stable software. All in all, this course helped me gain confidence working close to the hardware, managing resources carefully, and writing code that interacts directly with the OS and the network.