Tour Planner Web App
This app was built using Java Spark and Maven for the back-end and React and npm for the front-end. It was deployed to GitHub for releases, automation, workflows, and version control. It is an app that helps users build tours, whether for work or a vacation. Places can be added using the map or the add places button, both explained in detail in the belowe sections. These will appear as their names and display their coordinates in the list below the map. The app also allows you to optimize the tour so there are no overlapping lines and the trip can be efficient. The first location is the starting city and will also be the ending city so the distances are calculated using modulo so the last leg distance is between the last place and the first one. The tests were created using JUnit for unit testing, Jacoco and Jest for coverage testing, and Postman for integration testing.
Main features of the Program/Project
-Coordinated the development of an app using an agile based scrum methodology
-Applied front end tools, back end development, and dev ops
-Interacted with databases, apis, packages, and dependencies
-Used unit, coverage, and integration testing for best functionality
Tags
Java JavaScript SCSS ReactJS Postman ZenHub GitHub Workflows Testing jUnit Jacoco Maven Code Climate MariaDB MySQL Jest API HTTP TSP npm Spark SDLC Scrum Agile SprintImages and Demos of Program/Project
Using Dijkstra to Route Packages in a Network Overlay
The goal of this project was to use an overlay to communicate between messaging nodes (clients) and the Registry (server) to send messages using threads. It follows the principles of TCP/IP protocols and overlays used in P2P systems. The registry accepts messaging nodes using a server socket and creates receiver and sender threads for that connection. The messaging nodes also have their own sets of threads for the registry and peers. The foreground process in the Registry allows the users to specify commands that creates the undirected graph with all registered nodes, connect to peers to form bidirectional connections, and start sending messages. When all nodes finish messaging each other randomly, the statistics are collected and can be compared to see if any packets were lost during the period.
Main features of the Program/Project
-Effective use of threads and synchronization to avoid race conditions when accessing common data structures/methods
-Makes use of socket programming in Java to allow nodes to connect to the server using hostname and port number
-Uses good design principles such as Single Responsibility Principle, Singletons, Factories, Polymorphism, etc.
-Demonstrates the use of Dijkstra' algorithm to compute shortest path between all nodes registered in the system
-Utilizes principles from 1st and 3rd generations of P2P systems to build overlay and communicate using overlays/packets
-Applies the idea of caching using objects to efficiently retrieve the shortest paths from the node to its peers after using Dijkstra; this means the shortest path is not recomputed every time messages need to be sent
Tags
Java Gradle Distributed Systems Multithreaded Concurrency TCP P2P Dijkstra Sockets Client/Server SynchronizationImages and Demos of Program/Project
Graph Algorithms and Visualization
This is a working graph visualization and algorithms program that produces outputs to common graph algorithms and images for certain graphs. It uses the Graphviz library for C++ to generate graph images, but the other algorithms are implemented by me. There are four graphs produced by the directed and undirected versions each. Each will have information regarding the operation and print the graph along with the paths in red if applicable. As for the algorithms, the results are outputted to the console, but the program supports most algorithms on graphs.
Main features of the Program/Project
-Generate an image of directed and undirected graphs
-Finds the edges involved in SSSP using Dijkstra and produces a graph with the shortest path painted red
-Performs BFS and DFS on directed and undirected graph
-Prints out the adjacency matrix given the inputs
-For directed graphs, produces graphs with reversed edges
-For directed graphs, checks if the graph is a DAG
-For directed graphs, prints out the SDSP for all vertices using the reversed graph
-Finds and prints a matrix for APSP using Floyd-Warshall
-For undirected graphs, finds the MST and produces a graph with the span painted in red
-For undirected graphs, checks if the graph is bipartite
Tags
C C++ Graphviz Algorithms BigO Dijkstra Bellman Ford Floyd Warshall Prim BFS DFS Bipartite DAGImages and Demos of Program/Project
Distributed_Analytics_of_US_Residential_Zoning
This is a project that aims to do distributed analytics using clusters using a spatial dataset. Our goal with this project was to analyze the impact of single family rresidential zoning in the US and correlate it to quality of life measures in an effort to dissuade a segreggation of zoning types and promote inclusivity. We hoped to be able to compare the results against data from other countries that have more includive zoning laws, but this was not possible due to constraints on data availability and language barriers. For the distributed component, we are using a cluster of 10 machines that are managed by Yarn. To do the processing of data and calculations, we applied Spark using Java and Gradle. The data itself was stored using HDFS and totaled to ~3.2 GB. For more detail on our motivation, procedures, project structure, and results, please reference the latex file or the presentation in the GitHub repo.
Main features of the Program/Project
-Used Apache Spark with 10 machines to do analysis of a large dataset
-Collected zooning, quality of life, and cadastral data through various sources
-Uses HDFS to store the datasets and YARN to allocate resources to workers
-Applies RDDs, datasets, and SparkSQL in processing data using ~7 jobs for each region analyzed
Tags
Spark Hadoop HDFS Distributed Systems cluster Java Gradle Scala Jupyter Regression Machine learning latex disgramming PythonImages and Demos of Program/Project
Analysis of the MovieLens Dataset using Apache Spark
This project was an introduction to using Apache Spark to analyze a large file (~800 MB), namely the Movie Lens dataset containing movies, genres, ratings, etc. The files were stored using HDFS and cluster size consisted of 10 machines. There is 1 Java file with 7 Spark jobs which are focused on answering the 7 questions that can be found on GitHub.
Main features of the Program/Project
-Utilized Java and Scala to create multiple Spark jobs for data analysis
-Utilized YARN and HDFS to allocate resources and partition RDDs and store the data, respectively
Tags
Spark Apache HDFS Gradle SQL RDD Dataframe YARN cluster Distributed SystemsAnalysis of Million Songs Dataset using Hadoop MapReduce
This project was an introduction to using Hadoop MapReduce to analyze a large file (~1.6 GB), namely the Million Song subset containing 10,000 songs. The files were stored using HDFS and cluster size consisted of 10 machines. There are 10 Java files with jobs of their own which are focused on answering the 10 questions below. Please visit the github for more details on the questions, answers, and more.
Main features of the Program/Project
-Used Hadoop with Java and Gradle and utilized HDFS to store the dataset with a replication level of 3
-Utilized a cluster of 10 machines for concurrency
-Experimented with mappers, reducers, comparators, combiners, custom partitioners, and input and output files.
Tags
Hadoop HDFS cluster Java Gradle Multithreading MapReduce Big DataFast Multithreaded Matrix Multiplication
This is a very efficient matrix multiplication calculator built using Java and its concurrency libraries. It can be used to multiply matrices populated using a random seed, but it can also be modified to use predefined values. The command line gives you the option to define the size of the matrices, which will be the same for both matrices, the seed used in random to populate the matrices, and the number of threads. The features list below describes the optimizations.
Main features of the Program/Project
-Using a concurrent queue to efficiently use lock striping for better concurrency when accessing the queue; this means more threads can simultaneously access the tasks instead of having to block
-Using a countdown latch to notify the main thread when all tasks are complete
-Using tiling of tasks so each thread is operating on blocks of the matrix rather than individual cells; this helps reduce overhead of starting threads, blocking, memory and helps with cache coherency
-Flattening the 2D matrix to a 1D matrix so cells are contiguous and do not require accessing different sections of memory
-Transposing the 2nd matrix so that the multiplication is done row by row; this means there are no hops when reading from each cell
-Creating the thread pool efficiently so that tasks are performed quicker
Tags
Java Multithreading Gradle Optimization Parallel programming thread-pool concurrencyColor Coordinate Generator
This is a color coordinate sheet generator that is actively used in Vision Therapy. The goal was to use web development tags and explore accessibility.
Main features of the Program/Project
-Use the database connected using a PHP connector to add, edit, and delete colors
-Use Ajax and JQuery to dynamically create tables and populate nodes with colors from the database
-Form validation using PHP, JavaScript, and domain restrictions of the database
-Use the colors to paint the bottom table, which populates the upper table with the coordinates
-Display a print view of the final table without any colors displayed that can be colored in
Tags
JavaScript JQuery Ajax PHP HTML CSS MySQL SQLite3 GitHubJapanese-To-English Translator
This is a translator program I built using Python that will take in a sentence in Japanese and translate the parts of the sentence into English and return an English translation. The original senetence is first split into various parts of speech using Japanese particles, which determines the transitivity of the verb if present and if a copula is present. Each part of speech is further broken down depending on the characters, length, conjugation, pairing, and use. This program does utilize the googletrans library as making a translator is a near impossible task, especially without the use of machine learning. The main feature of the program is to take the individual parts of the sentence, translate it using a csv with common words in Japanese, match it to a part of speech in English, and return that to the user. To learn more, click on the github icon next to the title of the project.
Main features of the Program/Project
-Utilizes various packages in Python as noted below to get data, clean data, and use it
-Supports the use of 7 particles, which include は,に,を,が,の,よ,ね
-Can translate all forms and tenses of copula
-Able to translate transitive verbs, intransitive verbs, ある verbs, する verbs, いる verbs in all tenses and forms
-Supports the use of ている verbs
-Uses the common dataset of Japanese words, which includes ~8000 words from all JLPT levels and beyond
Tags
Python Jupyter Requests Pandas Numpy BeautifulSoup Time Os Csv JsonImages and Demos of Program/Project
Personal Website
The website you are on! This is my personal website I created using Python's Django framework for the back-end and pure Javascript, HTML, and CSS for the front-end with some help from Bootstrap5. Please feel free to explore the website and the various projects, courses, and features. If you would like to contact me, you can do so using the contact tab or my contact information from the sidebar.
Main features of the Program/Project
-Utilizes AWS S3 bucket for static file storage and PostgreSQL for the database
-Incorporates search capabilities using Django, contexts, and PostgreSQL
-Incorporates a canvas for drawing handwritten characters that utilizes Tensorflow and Fabric as well as a self-built CNN for digit recognition using the EMNIST dataset
-Integrates CSS, HTML, Bootstrap, and JavaScript to create a fully custom and responsive website
-Uses multiple navbars, carousels, flex boxes, modals, scrollspys, etc.
-Contains detailed information about my resume, projects, courses, work experience, etc.
-Combines many django apps that also use Python functions, data structures, and algorithms
Tags
Python Django CSS HTML PostgreSQL AWS S3 JavaScript Bootstrap UI/UX CDN W3.CSS Tensorflow CanvasHandwritten Letters to 3D-Printed Braille Letters
This is a team project for my CS370 class that involved the use of a Raspberry Pi to communicate and coordinate two external devices. I acted as the team leader and inititated the project, managed the repository for the project, and coordinated the tasks of each member. The goal of the project was to use a camera to take a picture of some handwritten text, which is then uploaded to the Raspberry Pi. Using Python, we would preprocess the image, and use OpenCV to find and extract contours, leading to individual letters of specific size. The letters would then be sequentially classified by a convolutional neural network trained using the EMNIST dataset on handwriting. After this, the letters are combined using stl models into a single 3D model along the y-direction. We used slic3r to slice the stl file into gcode using the shell and sent that to the Raspberry Pi using ssh and sftp. The pi would then serially send each line of gcode to the printer to be printed.
Main features of the Program/Project
-Uses OpenCV to find and extract contours from handwritten words
-Includes preprocessing of data, including Gaussian Blur, contrast and brightness correction, inversion of image, and sizing
-Used a neural network with the Keras framework to classify each letter according to labels
-The use of numpy-stl to combine stl files together, combine and add polygons, and transform the models
-Utilized slic3r through the command line using the subprocess module
-Used paramiko to send file sand execute commands over ssh using the network to communicate with the Raspberry Pi
-Used pyserial and ports to send and receive commands to the 3D printer
Tags
Git Github Python Jupyter OpenCV Keras TensorFlow Pyserial Paramiko Numpy-stl CNNImages and Demos of Program/Project
Data Augmentation Using Generative Adversarial Networks
This was a team project for my CS345 class, where I worked with a teammate to research and use GANs as a way to improve the accuracy of classifiers. We first researched neural networks and the workings of GANs to understand how the model functions. Then, we used TensorFlow as the framework to implement the GAN model to generate data that could be augmented to the test set. We trained the generator on various splits of the original training data and noted how effective the augmentation was. This was compared to the baseline accuracy of just the original data on a SVC classifier to train and test. The use case for this was to improve the data on which to test as a mean of improving the accuracy of the classifier with better data produced by the GAN.
Main features of the Program/Project
-Used SVC classifier to test accuracy on train, test, and validation data
-Compared the effects of GANs on large datasets (10,000 rows) to small datasets (400 rows)
-Applied the TensorFlow framework for GANs to augment data using the training data
-Applied various splits for comparing the performace of GANs
-Utilized pandas and matplotlib to analyze results and showcase them visually
Tags
Python Jupyter TensorFlow Numpy Pandas Kaggle Keras Scikitlearn MatplotlibHeuristic Algorithms for Approximating the Traveling Salesman Problem
This program will approximate the Traveling salesman problem using 3 three different algorithms (Nearest Neighbot, 2Opt, and 3Opt). There are size different combinations and explanations for these can be found in the sections below. The program allows you to run each algorithm individually or run a benchmark for all 6 and the original unoptimized list. The results are formatted in a table and displayed in the console. As the algorithms have different time complexities, the time it takes increases for some algorithms drastically, so use caution when using many places.
Main features of the Program/Project
-Lets the user generate places with random seeds, radius to use, and the algorithm
-Can choose between a combination of 6 algorithms to run individually or a benchmark of all at once
-Benchmark results are displayed in the console with their time and total distance
-Individual distances are output to a file for all sequential pairs of places
Tags
TSP Travelling Salesman Java Algorithm Nearest+Neighbor Gradle 2opt 3opt heuristicsGreat Circle Distance Calculators
This program calculates the distances between coordinates using a possible of three formulas: Vincenty, Cosines, or Haversine. You can choose to use places through the command line or through a file. I would recommend using the file for more than 5 places as it becomes cumbersome to keep adding it through the shell. You can also choose to generate any number of places and then do the calculations.
Main features of the Program/Project
-Lets the user generate places with coordinates and names using random seeds, radius to use, formula to use, and number of places
-Uses factory pattern, singleton pattern, polymorphism, inheritence, and good Java design practices
-Outputs distances from one place to the next in a file
Tags
Java Gradle Great+Circle+Distance Vincenty Haversine CosinesInfix Expression Calculator
This calculator app utilizes Java and the Swing framework for the calculations and design. Each frame, panel, and component is custom design that is made to look similar in GUI to the calculator offered by Microsoft. It features tons of operations, help menus, an output screen, an operation screen, history tab with details abou the previous calculations, etc. For the actual calculations, it is programmed in Java, so it utilizes most available data structures, sorting algorithms, paring, error handling, etc.
Main features of the Program/Project
-Supports the operations: Addition, Subtraction, Multiplication, Division, Sqrt, Square, and any combinations
-Allows you to input any expressions as you would see them normally, or as infix operations
-Custom GUI designed to be similar to Microsoft's calculator
-Supports negatives and decimals
-Features a working history tab that saves calculations onto a file that is loaded on start
-Utilizes maps, sets, linked lists, array lists, 2D arrays, and files
Tags
Java Swing Github UI/UX Java stream Functional ProgrammingImages and Demos of Program/Project
Descriptive Statistics Calculator
This application was inspired by my statistics class, of which one of the chapter was descriptive. In the input screen, you are able to input any number of data values, which are used by the program to calculate and display the descriptive statistics associated with them. The output panel displays the count, frequency of data, min, max, median, IQR, sum, mean, range, variance, and standard deviation. Please look at the images below for reference. This is saved to the history tab each time, which can be clicked on to display all of the statistics in a screen.
Main features of the Program/Project
-Utilizes Functional Programming in Java such as stream, intermediate functions, and terminal functions throughout the program
-Incorporates a history system which stores previous calculations to the hard drive and displays them in a tab by reading from the saved file
-Allows the user to input a list of values and displays a table with statistical information about the data
Tags
Java Swing Github UI/UX Java stream Functional ProgrammingImages and Demos of Program/Project
