A Software Engineer's Blog

Hi, I’m Xinrui

10 years experiences software engineer focus on Frontend now and working for Amazon AWS in Seattle WA

SDE & FEE

fullstackguy@gmail.com

Seattle WA

Download my resume:

DOWNLOAD RESUME CONTACT ME

Over 10 years of experience

My Experience

June 2020 - Present

Front End Engineer II

Lead Frontend projects in AWS IAM and AWS T&C

Amazon - Seattle, WA

July 2019 - May 2020

SDE II

Build Expedia Insurance Widget

Expedia Group - Seattle, WA

Sep 2018 - Mar 2019

Senior Member of Technical Staff

OCI Console Development

Oracle - Seattle, WA

July 2017 - Sep 2018

Software Engineer / Senior Associate

Built Capital One Investing Tools

Capital One - McLean, VA

Oct 2015 - July 2017

Software Engineer

AOL On Team, built App Generator

AOL - Sterling, VA

June 2014 - Oct 2015

Web Developer

Build AP, SAT tests registration system

College Board - Reston, VA

Master and Bachelor, with a PhD Offer

Education

2012 - 2014

Master of Science in Computer Science

George Washington University

Washington DC

South-Central Minzu University For Nationalities

2008 - 2012

BS - Computer Science

South-Central Minzu University For Nationalities

Hubei Wuhan, China

10+ Years of Experience

My Resume

2008 - 2014

Education Quality

MS in Computer Science

George Washington University (2012 - 2014)

3.90/4

The training provided by universities in order to prepare me to work in various sectors of the computer science area.

BS in Computer Science

South-Central Minzu University For Nationalities (2008 - 2012)

4.75/5

I get my foundation of CS built here, I learn from the lower level operation system, network, Assembly language to Database, Java and data structure.

2014 - Present

Job Experience

Front End Engineer II

AWS IAM Team, AWS ILT Team, AWS PxT - (2020 - Present)

SEATTLE

Using React, Redux, React Query, Webpack and TypeScript to build AWS IAM Console, integrate with backend APIs, develop a widget system that can plug and play with other AWS Console.

SDE II

Expedia Insurance Team - (2019 - 2020)

SEATTLE

Re-design the Expedia checkout insurance module experience, re-write the jQuery based module to React widgets.

Senior Member of Technical Staff

Oracle Cloud Infrastructure - (2018 - 2019)

SEATTLE

The India economy has grown strongly over recent years, having transformed itself from a producer and innovation-based economy.

2014 - Present

Job Projects

App Generator

AOL On Team - (2015 - 2017)

Sterling VA

App Generator is an all-in-one platform designed for businesses or individuals lacking a development team but wishing to create their own video app. It utilizes technologies such as Angular, Java, and Swift to offer a user-friendly interface where users can select their desired video content and target platform. Ultimately, it generates a customizable app tailored to their needs. Additionally, the platform allows for on-the-fly updates to app content and themes, eliminating the need for frequent app version upgrades.

Re-write IAM Console

AWS IAM Team - (2020 - 2021)

Seattle WA

The AWS IAM Console, ranking as the third most trafficked service on the AWS platform, currently operates on an outdated framework that incorporates a blend of technologies like AngularJS 1.6, Backbone, and Ruby, making it challenging to read and maintain. We are embarking on a complete overhaul of the entire IAM console to enhance usability and maintainability. By adopting modern technologies such as React, Redux, TypeScript, React Query, and REST API, we aim to streamline the architecture while preserving the original user experience.

AWS re:Invent - Access Analyzer

AWS IAM Team

Seattle WA

I spearheaded the frontend segment of the re:Invent project titled "Least Privilege Policy Generator." This tool is designed to analyze a policy over a certain period, identify the services accessed, and refine the policy to limit its scope to only necessary permissions. Consequently, it mitigates the risk associated with granting overly broad policies to unintended recipients.

2014 - Present

Personal Projects

Rescue Diver

PADI Certified Rescue Diver

Bonarie & Mexico

I have successfully completed scuba diving training and achieved certifications in various disciplines, including PADI Open Water, Advanced Open Water, Enriched Air Diver, and EFR-Primary Care (CPR) & Secondary Care. Additionally, I am an SSI-certified Freediver.

Web Developer and Instructor

always on the road

USA

I have developed numerous websites, including e-commerce platforms for companies such as Biovive, Reflexgroup, and WolfTech Studio, showcasing this very site as an example of my work. Leveraging my extensive experience, I also mentor individuals aspiring to learn website development. My expertise spans across all web technologies, from historical methods like modifying HTML/CSS for IE6 compatibility, crafting class-like JavaScript structures before the advent of ES6 and TypeScript, to implementing functionalities traditionally handled by modern frameworks like React and Bootstrap using plain JavaScript/CSS. Furthermore, I am skilled in creating responsive designs with pure CSS, alongside other now less commonly discussed techniques.

Game Developer

Personal projects for fun

AT HOME

I Like many others, I enjoy playing video games, which inspired me to learn how to create them myself. I self-taught various game engines, including Phaser, Unity, and Three.js, and have used these tools to develop games such as Flappy Bird and Ping-Pong, among others.

Script Writter

When I need robots do something for me.

Cypress

I write scripts to automate some tasks, mostly using Cypress Integration Test framework.

Visit my blog and keep your feedback

October 30, 2024

Unlocking the Lock: Solving the “Open the Lock” Problem with BFS

Today, we’re diving into a classic interview problem, Open the Lock. This problem requires us to use Breadth-First Search (BFS) to find the shortest path by simulating a lock mechanism with four wheels. Let’s walk through the problem step-by-step, analyze the solution, and cover key details in the code.

Problem Overview

The problem describes a lock with four rotating wheels, each numbered from 0 to 9. The lock starts at “0000”, and each wheel can be rotated up or down to the next number. For instance, “0” can rotate to “1” or “9”.

We have a list of deadend combinations. If we reach one of these, the lock stops, and we can’t proceed further from that position. Given these constraints, we need to find the minimum number of moves to turn the lock from “0000” to a target combination target. If it’s impossible, we return -1.

Approach

Since we’re trying to find the shortest path to the target, this problem is a perfect candidate for Breadth-First Search (BFS). BFS explores all paths level by level, ensuring we reach the target in the fewest moves possible.

Step-by-Step Solution Outline:

Initialization: Store all deadends in a Set for quick lookup.
BFS: Begin from “0000” and explore every possible combination by turning each wheel up or down.
Track Moves: Use a queue to store each combination and the current move count, increasing it by one each level.

Code Implementation with Comments

/**
 * @param {string[]} deadends - List of dead-end combinations
 * @param {string} target - Target combination
 * @return {number} - Minimum moves to reach target from "0000", or -1 if impossible
 */
var openLock = function(deadends, target) {
    // Initialize a Set for deadends for quick lookup
    const seen = new Set(deadends);
    
    // Handle edge cases: if "0000" or target is in deadends, we can't proceed
    if (seen.has(target) || seen.has('0000')) return -1;
    
    // If the start is already the target, no moves are needed
    if (target === '0000') return 0;
    
    // Initialize BFS queue and moves counter
    const queue = ["0000"];
    seen.add("0000"); // Mark "0000" as visited
    let steps = 0;

    // Main BFS loop
    while (queue.length > 0) {
        // Number of nodes in the current level
        let size = queue.length;
        
        // Process each node in the current level
        while (size > 0) {
            const current = queue.shift(); // Remove the first element in queue
            
            // If we've reached the target, return the steps taken
            if (current === target) return steps;
            
            // Generate all possible next moves and add to queue
            const comb = generateComb(current);
            for (const next of comb) {
                if (!seen.has(next)) { // Only add unvisited nodes
                    queue.push(next);  // Add new combination to queue
                    seen.add(next);     // Mark new combination as visited
                }
            }
            size--; // Decrement level size
        }
        steps++; // Move to the next level (increment moves)
    }
    
    // If BFS completes without finding target, return -1
    return -1;
};

/**
 * generateComb - Generates all possible next moves for a given lock state
 * @param {string} input - Current lock state
 * @return {string[]} - Returns all possible next moves
 */
var generateComb = function(input) {
    const combinations = [];
    
    // Loop through each of the four wheels
    for (let i = 0; i < 4; i++) {
        // Get the current digit of the wheel
        const digit = parseInt(input[i]);
        
        // Roll the digit up by one (wrap around from 9 to 0)
        const up = input.slice(0, i) + ((digit + 1) % 10) + input.slice(i + 1);
        combinations.push(up); // Add the new combination to the result array
        
        // Roll the digit down by one (wrap around from 0 to 9)
        const down = input.slice(0, i) + ((digit - 1 + 10) % 10) + input.slice(i + 1);
        combinations.push(down); // Add the new combination to the result array
    }
    
    return combinations;
};

Detailed Code Explanation

Main Function openLock:
- The seen set stores all visited states to prevent revisiting deadends and previous combinations.
- We initialize a queue to store each combination and mark “0000” as visited to prevent reprocessing.
- The BFS loop processes nodes level by level, allowing us to find the shortest path to target.
Combination Generator generateComb:
- For each digit in the 4-digit lock, we generate two new states: one by rolling the digit up and one by rolling it down.
- Each new combination is added to the result array, which is then returned to the BFS loop for further processing.
Core Logic:
- BFS systematically expands from the start state, checking all possible next moves.
- The algorithm uses steps to count levels, ensuring that when we reach target, it’s in the minimum moves.
- If BFS finishes without finding target, we return -1, as it’s impossible to reach.

Example Walkthrough

Consider the case where deadends = ["0201","0101","0102","1212","2002"] and target = "0202":

Initial State: queue = ["0000"], steps = 0
First Level (step = 1): From “0000”, we expand to “1000”, “9000”, “0100”, “0900”… adding all valid moves to the queue.
Subsequent Levels: We keep expanding outward, avoiding deadends and marking visited states.
Final Steps: Eventually, we reach “0202” in the minimum moves and return the step count.

Conclusion

This problem is an excellent example of BFS’s utility in finding shortest paths. Key takeaways include:

Using BFS: For shortest path problems where each move has equal weight, BFS provides an efficient approach.
Tracking Visited States: By storing visited states, we avoid deadends and reduce redundant processing.
Generating Moves: By iterating through each digit and generating moves, we simulate all possible paths from a given state.

By practicing with problems like this, you’ll improve your understanding of BFS and how to apply it to real-world scenarios!

October 18, 2024

Implementing a Priority Queue in TypeScript: A Step-by-Step Guide

Priority queues are essential data structures in computer science, especially when dealing with tasks that require ordering based on priority. In this blog post, we’ll explore how to implement a priority queue in TypeScript, which can help solve problems like LeetCode’s 215. Kth Largest Element in an Array.

Introduction

A priority queue is a special type of queue where each element is associated with a priority, and elements are served based on their priority. The higher the priority, the sooner the element is dequeued. We’ll implement a min-heap-based priority queue, which ensures that the element with the smallest value (highest priority) is always at the front.

Why TypeScript?

TypeScript adds static typing to JavaScript, providing better tooling and error checking at compile time. This makes our code more robust and maintainable.

Step 1: Define the Priority Queue Class

First, let’s create a PriorityQueue class that will hold our heap.

TypeScript

class PriorityQueue<T> {
  private heap: T[] = [];

  constructor(private comparator: (a: T, b: T) => number) {}
}

heap: An array representing the binary heap.
comparator: A function to compare two elements, defining the priority.

Step 2: Implement the Helper Methods

Swap Method

We need a method to swap two elements in the heap.

TypeScript

private swap(i: number, j: number): void {
  [this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]];
}

Parent and Child Index Methods

Calculate the indices of parent and child nodes.

Complete Binary Heap Index is easy to get using an array index

TypeScript

private parentIndex(index: number): number {
  return Math.floor((index - 1) / 2);
}

private leftChildIndex(index: number): number {
  return 2 * index + 1;
}

private rightChildIndex(index: number): number {
  return 2 * index + 2;
}

Step 3: Implement the Push Method

Add a new element to the heap and reorder it to maintain the heap property.

TypeScript

push(item: T): void {
  this.heap.push(item);
  this.heapifyUp();
}

Heapify Up

Move the new element up to its correct position.

TypeScript

private heapifyUp(): void {
  let index = this.heap.length - 1;
  while (
    index > 0 &&
    this.comparator(this.heap[index], this.heap[this.parentIndex(index)]) < 0
  ) {
    this.swap(index, this.parentIndex(index));
    index = this.parentIndex(index);
  }
}

Step 4: Implement the Pop Method

Remove and return the element with the highest priority.

TypeScript

pop(): T | undefined {
  if (this.heap.length === 0) return undefined;
  if (this.heap.length === 1) return this.heap.pop();

  const item = this.heap[0];
  this.heap[0] = this.heap.pop() as T;
  this.heapifyDown();
  return item;
}

Heapify Down

Reorder the heap after removing the root element.

TypeScript

private heapifyDown(): void {
  let index = 0;
  const length = this.heap.length;

  while (this.leftChildIndex(index) < length) {
    let smallestChildIndex = this.leftChildIndex(index);
    const rightChildIdx = this.rightChildIndex(index);

    if (
      rightChildIdx < length &&
      this.comparator(this.heap[rightChildIdx], this.heap[smallestChildIndex]) < 0
    ) {
      smallestChildIndex = rightChildIdx;
    }

    if (
      this.comparator(this.heap[index], this.heap[smallestChildIndex]) <= 0
    ) {
      break;
    }

    this.swap(index, smallestChildIndex);
    index = smallestChildIndex;
  }
}

Step 5: Implement Peek and Size Methods

Get the element with the highest priority without removing it and get the size of the queue.

TypeScript

peek(): T | undefined {
  return this.heap[0];
}

size(): number {
  return this.heap.length;
}

Step 6: Implement the Update Method

Now, we’ll implement an update() method that allows us to update the priority of an element, either by its index or by its value.

Update by Index

TypeScript

updateAt(index: number, newValue: T): void {
  if (index < 0 || index >= this.heap.length) {
    throw new Error("Index out of bounds");
  }

  const oldValue = this.heap[index];
  this.heap[index] = newValue;

  if (this.comparator(newValue, oldValue) < 0) {
    this.heapifyUp(index);
  } else {
    this.heapifyDown(index);
  }
}

Explanation: We replace the value at the given index with the new value. Then, depending on how the new value compares to the old value, we either heapify up or heapify down to restore the heap property.

Update by Value

Since updating by value can be inefficient (as it may require searching the entire heap), we’ll implement it cautiously.

TypeScript

update(value: T, newValue: T): void {
  const index = this.heap.findIndex((element) => element === value);
  if (index === -1) {
    throw new Error("Value not found in heap");
  }
  this.updateAt(index, newValue);
}

Explanation: We find the index of the value in the heap and then call updateAt() to update it.

Remove and Remove By Index

TypeScript

  public remove(item: T): void {
    const index = this.heap.indexOf(item);
    if (index === -1) {
      throw new Error('item not found');
    }
    this.removeAtIndex(index);
  }

  private removeAtIndex(index: number): void {
    if (index < 0 || index >= this.heap.length) {
      throw new Error('index out of bounds');
    }
    if (index === this.heap.length - 1) {
      this.heap.pop();
    } else {
      this.heap[index] = this.heap.pop() as T;
      const parentIndex = this.parent(index);
      if (index > 0 && this.compare(this.heap[index], this.heap[parentIndex]) < 0) {
        this.heapifyUp(index);
      } else {
        this.heapifyDown(index);
      }
    }
  }

Step 7: Implement the Heapify Function

We’ll add a heapify() method to build a heap from an existing array.

TypeScript

heapify(array: T[]): void {
  this.heap = array;
  for (let i = Math.floor(this.heap.length / 2) - 1; i >= 0; i--) {
    this.heapifyDown(i);
  }
}

Step 8: Use the Priority Queue to Solve LeetCode 215

Now, let’s use our PriorityQueue to find the Kth largest element in an array.

Problem Statement

Given an integer array nums and an integer k, return the kth largest element in the array.

Solution

We’ll use a min-heap (priority queue) to keep track of the largest k elements.

TypeScript

function findKthLargest(nums: number[], k: number): number {
  const pq = new PriorityQueue<number>((a, b) => a - b);

  for (const num of nums) {
    pq.push(num);
    if (pq.size() > k) {
      pq.pop();
    }
  }

  return pq.peek() as number;
}

Comparator: (a, b) => a - b ensures a min-heap.

Logic: Maintain a heap of size k. The root will be the kth largest element.

Full Code Listing with small changes in variable names

TypeScript

class PriorityQueue<T> {
  private heap: T[];

  constructor(private compare: (a: T, b: T) => number) {
    this.heap = [];
  }

  private swap(i: number, j: number): void {
    [this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]];
  }

  private parent(i: number): number {
    return Math.floor((i - 1) / 2);
  }

  private left(i: number): number {
    return 2 * i + 1;
  }

  private right(i: number): number {
    return 2 * i + 2;
  }

  private heapifyUp(index: number): void {
   while (index > 0 && this.compare(this.heap[index], this.heap[this.parent(index)]) < 0) {
    this.swap(index, this.parent(index));
      index = this.parent(index);
    }
  }

  private heapifyDown(index: number): void {
    const length = this.heap.length;

    while (this.left(index) < length) {
      let smallest = this.left(index);
      const rightIndex = this.right(index);
      if (rightIndex < length && this.compare(this.heap[rightIndex], this.heap[smallest]) < 0) {
        smallest = rightIndex;
      }
      if (this.compare(this.heap[index], this.heap[smallest]) < 0) {
        break;
      }
      this.swap(index, smallest);
      index = smallest;
    }
  }

  public push(item: T): void {
    this.heap.push(item);
    this.heapifyUp(this.heap.length - 1);
  }

  public pop(): T | undefined {
    if (this.heap.length === 0) return undefined;
    if (this.heap.length === 1) return this.heap.pop();

    const root = this.heap[0];
    this.heap[0] = this.heap.pop() as T;
    this.heapifyDown(0);
    return root;
  }

  public peek(): T | undefined {
    return this.heap[0];
  }

  public size(): number {
    return this.heap.length;
  }

  public updateAtIndex(index: number, newItem: T): void {
    if (index < 0 || index >= this.heap.length) {
      throw new Error('index out of bounds');
    }
    this.heap[index] = newItem;
    if (this.compare(newItem, this.heap[this.parent(index)]) < 0) {
      this.heapifyUp(index);
    } else {
      this.heapifyDown(index);
    }
  }

  public update(item: T, newItem: T): void {
    const index = this.heap.indexOf(item);
    if (index === -1) {
      throw new Error('item not found');
    }
    this.updateAtIndex(index, newItem);
  }

  public remove(item: T): void {
    const index = this.heap.indexOf(item);
    if (index === -1) {
      throw new Error('item not found');
    }
    this.removeAtIndex(index);
  }

  private removeAtIndex(index: number): void {
    if (index < 0 || index >= this.heap.length) {
      throw new Error('index out of bounds');
    }
    if (index === this.heap.length - 1) {
      this.heap.pop();
    } else {
      this.heap[index] = this.heap.pop() as T;
      const parentIndex = this.parent(index);
      if (index > 0 && this.compare(this.heap[index], this.heap[parentIndex]) < 0) {
        this.heapifyUp(index);
      } else {
        this.heapifyDown(index);
      }
    }
  }

  public isEmpty(): boolean {
    return this.heap.length === 0;
  }

  public heapify(array: T[]): void {
    this.heap = array;
    for (let i = Math.floor(this.heap.length / 2); i >= 0; i--) {
      this.heapifyDown(i);
    }
  }
}

Testing the Solution

Let’s test our implementation with an example.

const nums = [3, 2, 1, 5, 6, 4];
const k = 2;

const result = findKthLargest(nums, k);
console.log(`The ${k}th largest element is ${result}`); // Output: 5

Testing the Update and Heapify Methods

Using `heapify()` to Build a Heap from an Array

typescriptCopy codeconst nums = [3, 2, 1, 5, 6, 4];
const pq = new PriorityQueue<number>((a, b) => a - b);
pq.heapify(nums);

console.log(pq.peek()); // Output: 1

Rewriting the `findKthLargest` Function Using `heapify()`

We can optimize our earlier findKthLargest function by using heapify().

TypeScript

function findKthLargest(nums: number[], k: number): number {
  const pq = new PriorityQueue<number>((a, b) => b - a); // Max-heap

  pq.heapify(nums);

  for (let i = 0; i < k - 1; i++) {
    pq.pop();
  }

  return pq.peek() as number;
}

Why Use `heapifyDown()` in `heapify()`?

That’s a great question! In the heapify() method, we use heapifyDown() instead of heapifyUp() because when building a heap from an existing array, we need an efficient way to ensure the heap property is maintained throughout the structure.

When constructing a heap from an unordered array, the most efficient method is to start from the last non-leaf node and move upwards, performing heapifyDown() on each node. This process is known as the heapify algorithm or build heap.

Reasons:

Higher Efficiency:
- Lower Time Complexity: Using heapifyDown(), the overall time complexity of building the heap is O(n). If we were to use heapifyUp(), the time complexity would increase to O(n log n) in the worst case.
- Fewer Node Movements: heapifyDown() can fix all violations of the heap property from the current node down to the leaves in one pass, whereas heapifyUp() might require multiple passes for each node.
Suitable for Building the Entire Heap:
- heapifyDown() is more appropriate when you need to adjust the heap starting from the internal nodes downwards.
- heapifyUp() is typically used when inserting a new element into an already built heap.

Detailed Explanation

When building a heap, our goal is to ensure that every parent node satisfies the heap property with respect to its children (for a min-heap, each parent node is less than or equal to its children). To achieve this efficiently, we start from the last non-leaf node because leaf nodes are already valid heaps by themselves.

heapify(array: T[]): void {
  this.heap = array;
  for (let i = Math.floor(this.heap.length / 2) - 1; i >= 0; i--) {
    this.heapifyDown(i);
  }
}

Calculating the Starting Index: Math.floor(this.heap.length / 2) - 1
- This formula gives us the index of the last non-leaf node.
- In a binary heap, nodes with indices from Math.floor(n/2) to n - 1 are all leaf nodes.
Why Not Use heapifyUp()?
- heapifyUp() is suitable for situations where you’re adding a single new element to the heap and need to adjust its position.
- Using heapifyUp() during the heap construction process would result in higher time complexity because each node might need to be moved up multiple levels.
- In contrast, heapifyDown() can adjust the subtree rooted at a node in one pass.

An Example

Suppose we have an array [3, 2, 1, 5, 6, 4] and we want to build a min-heap.

Initialize the Heap:typescriptCopy codethis.heap = [3, 2, 1, 5, 6, 4];
Start from the Last Non-Leaf Node:
- The array length is 6, so the index of the last non-leaf node is Math.floor(6 / 2) - 1 = 2.
Perform heapifyDown() on Index 2:
- The node at index 2 has a value 1, and its children are out of bounds, so no action is needed.
Perform heapifyDown() on Index 1:
- The node at index 1 has a value 2, with left child 5 and right child 6.
- Since 2 is less than its children, no action is needed.
Perform heapifyDown() on Index 0:
- The node at index 0 has a value 3, with left child 2 and right child 1.The right child 1 is the smallest, so we swap 3 with 1.
- The heap now looks like [1, 2, 3, 5, 6, 4].
Continue heapifyDown() on the Swapped Node:
- The node at index 2 (now with value 3) has a left child 4, but since 3 is less than 4, no further action is needed.

Summary

Using heapifyDown():
- Ideal for building a heap from an array.
- Overall time complexity is O(n).
Using heapifyUp():
- Suitable for inserting a single element into an existing heap.
- Each insertion has a time complexity of O(log n).

Therefore, in the heapify() method, we choose heapifyDown() to efficiently build a valid heap from the bottom up.

Additional Notes

Why Not Use heapifyUp()?
- If we used heapifyUp() on each node starting from the root, each node might have to move up several levels, leading to higher overall time complexity.
- heapifyDown() allows us to fix violations of the heap property starting from each internal node down to the leaves in a single pass.
Time Complexity Comparison:
- Using heapifyDown(): Total time complexity is O(n).
- Using heapifyUp(): Total time complexity is O(n log n).

Conclusion

We’ve successfully implemented a priority queue in TypeScript using a min-heap and applied it to solve a common algorithm problem. This implementation can be extended or modified for other use cases, such as max-heaps or custom priority criteria.

References

Contact

Contact With Me

Xinrui Ma

Software Engineer

I am available for freelance work, or you have a great job opportunity. Connect with me via email below. The contact form I would advise you not to use that due to connection issue.

Email: fullstackguy@gmail.com

Hi, I’m Xinrui

My Experience

Front End Engineer II

Lead Frontend projects in AWS IAM and AWS T&C

SDE II

Build Expedia Insurance Widget

Senior Member of Technical Staff

OCI Console Development

Software Engineer / Senior Associate

Built Capital One Investing Tools

Software Engineer

AOL On Team, built App Generator

Web Developer

Build AP, SAT tests registration system

Education

Master of Science in Computer Science

George Washington University

BS - Computer Science

South-Central Minzu University For Nationalities

My Resume

Education Quality

MS in Computer Science

BS in Computer Science

Job Experience

Front End Engineer II

SDE II

Senior Member of Technical Staff

Life Skills

Scuba Diving

Basketball

Saltwater fish aquarium

Cooking Chinese food

Piano

Development Skill

React

NodeJS

JAVASCRIPT

AWS

Java

Job Projects

App Generator

Re-write IAM Console

AWS re:Invent - Access Analyzer

Personal Projects

Rescue Diver

Web Developer and Instructor

Game Developer

Script Writter

Unlocking the Lock: Solving the “Open the Lock” Problem with BFS

简单易懂的TypeScript哈希表教程

Implementing a Priority Queue in TypeScript: A Step-by-Step Guide

Contact With Me

Xinrui Ma