Relevant Computer Science Courses Taken Thus Far


Description Tools Learned/Used
COS 126 Intro to Programming Java.
COS 226 Algorithms and Data Structures More advanced Java, algorithms and data structures.
COS 217 Introduction to Programming Systems C, assembly language, machine language.
COS 333 Web and App Development CSS, HTML, Python, AJAX, Flask, Bootstrap, JavaScript, J-Query, cybersecurity.


School Projects:


COS 126: Computer Science: An Interdisciplinary Approach (in Java); Fall 2021.

  1. Machine Learning Classifier

    Designed a program to classify images using the perceptron algorithm.

  2. TSP

    Implemented two greedy heuristics to find good (but not optimal) solutions to the traveling salesperson problem.

COS 226: Algorithms and Data Structures (in Java); Spring 2022.

  1. Percolation

    Goal: A program that estimates the value of the percolation threshold via Monte Carlo simulation. This program is a model that can be applied to real-life purposes, such as: given a porous landscape with water on the surface (or oil below), under what conditions will the water be able to drain through to the bottom (or the oil to gush through to the surface)?

    Details: The Monte Carlo simulation consists of two conditions: 1) initializing all sites to be blocked. 2) repeating the following until the system percolates: choose a site uniformly at random among all blocked sites; then open that site. The fraction of opened sites when the system percolates provides an estimate of the percolation threshold.

  2. Autocomplete

    Goal: Built a program in collaboration with a classmate that performs the function of auto-completion employed by modern applications, such as web browsers.

    Details: Given a prefix, the program finds all queries that start with the given prefix and predicts how likely it is that the user is typing each query, presenting to the user a list of the top-matching queries in descending order of weight. This was implemented by sorting the terms by query string; binary searching to find all query strings that start with a given prefix; and sorting the matching terms by weight. The weight indicates how likely a word is the one that the user intends to write.

  3. WordNet

    Goal: To measure the relatedness of two nouns using the WordNet diagraph.

    Details: Wordnet groups words into sets of synonyms called synsets. It also describes semantic relationships between synsets, such as connecting a hyponym (more specific synset) to a hypernym (more general synset). For example, the hyponym synset {gate, logic gate} is a hypernym of {AND circuit, AND gate} because an AND gate is a type of logic gate. The built WordNet diagraph has each vertex v as an integer that represents a synset, and each directed edge v --> w represents that w is a hypernym of v. The diagraph is a rooted DAG, which means that it is acyclic and has one vertex - the root - that is an ancestor of every other vertex. However, it is not necessarily a tree because a synset can have more than one hypernym.

  4. Seam Carving

    Goal: Implement a content-aware image resizing algorithm. This algorithm is a core feature in Adobe Photoshop and other computer graphics applications.

    Details: To resize images without significantly losing the picture quality, this program preserves the most important features (aspect ratio, set of objects present, etc) of the image. It accomplishes doing so by: 1) computing the energy of every pixel in the image, using the dual-gradient energy function; 2) finding a vertical or horizontal seam with minimum energy. A seam consists of pixels connected together across the image, either horizontally or vertically; 3) removing all of the pixels along the vertical or horizontal seam.

  5. Burrows-Wheeler

    Goal: Implement the Burrows-Wheeler algorithm for data compression, which presently forms the basis of the Unix compression utility bzip2.

    Details: The Burrows-Wheeler data compression algorithm consists of three algorithmic components, which are applied in succession: 1) Burrows-Wheeler transform, which transforms a typical English text file into a file in which sequences of the same character occur near each other many times. 2) Move-to-front encoding, which converts the processed text file from step 1 into a file in which certain characters appear much more frequently than others. 3) Huffman compression- compresses the processed file from step 2 by encoding frequently occurring characters with short codewords and infrequently occurring characters with long codewords. I implemented the first two steps. Step 1 and 2 make the huffman compression particularly effective because they produce a text file in which certain characters appear much more frequently than others.

COS 217: Introduction to Programming Systems (in C and Assembly Language); Fall 2022.

  1. Decomment

    Goal: Implement details of the "de-commenting" task of the C preprocessor to better understand how it works.

    Details: Using a DFA designed with the required logic for all of the various functionalities and conditions that the program should take into consideration after reading each character from stdin from a given text file, this de-commenting program replaces comments (text outside string and character literals) with a space character and newline characters as originally found in the comment in order to preserve line numbering. Returns 0 (EXIT_SUCCESS) if there are no unterminated comments; otherwise returns EXIT_FAILURE with an error message to stderr.

  2. String Module and Client

    Goal: Use arrays, pointers, and stateless modules in C; utilize the "design by contract" style of programming; use the Linux operating system and the GNU programming tools, especially bash, emacs and gdb.

    Details: Composed a str module containing versions of the most commonly used standard string handling functions in the C language. Specifically, designed an str module that contains these functions, each of which behaves the same as the corresponding standard C functions: strlen, strcpy, strcat, strcmp, and strstr.

  3. Symbol Table ADT

    Goal: Use dynamic memory management to create abstract data types (ADTs) in C, and gain more experience with the Linux operating system and the GNU programming tools, such as bash, gdb and make.

    Details: Implement two versions of a symbol table (an unordered collection of bindings), one using arrays and another using linked lists. A binding consists of a key and a value. A key is a string that uniquely identifies its binding; a value is data that is somehow pertinent to its key. A symbol table allows its client to insert (put) new bindings, to retrive (get) the values of bindings with specified keys, and to remove bindings with specified keys. Symbol tables are used often in programming systems: compilers, assemblers, and execution profilers use them extensively.

  4. Directory and File Tree Abstract Objects

    Goal: The purpose of this project was:

    1. To read substantial amounts of code that I did not write and to get up to speed on the codebase quickly.
    2. To debug with a structured, systematic approach.
    3. To design thorough internal testing, particularly relating to invariants of a datatype (i.e., the characteristics of the internal state of a data structure that result in invalid instances of it).
    4. To create new implementations for a given interface and making sensible design decisions about program structure and modularity.

    Details: For the last portion of this project, I created a new implementation for the given interface. This new implementation consisted of expanding upon the directory tree (DT) interface to a file tree (FT). FT is an extension of a DT in which leaves may now represent either an empty directory or a file. The difference between a file and a directory is that a file can contain data of any type and cannot have any child nodes, while a directory cannot have data but can have child nodes. The root is the only directory node that has no parent.


Personal Projects:


  1. Photo album of alphabet on Princeton Campus: created a webpage in collaboration with members in the Daily Princetonian Web Design team to implement an album of photos taken by students around campus of natural sites containing objects resembling alphabet letters.

    Importance: Put into practice CSS and HTML skills that I learned on my own during the summer of 2021.