Notes on Yixian Wang

Latex

Mon, 23 Oct 2023 23:51:32 -0400

$\KaTeX$ is used for rendering LaTeX math expressions. It can be enabled per page by setting math to true in the page front matter.

Claude Tips

Sat, 28 Mar 2026 09:03:40 -0400

.claude > TODO.md
#

# project-name TODO

## In Progress (from git status)
- [ ] Commit widget implementation changes
    - [ ] folder/file
    - [ ] folder/new-file (new)
    - [ ] folder.new-file2 (new)
- [ ] Commit Live Activityand entitlements updates

## Build & Validation Commands
**IMPORTANT: After every code change, validate the build succeeds.**
```bash
# Build for xxx

# Quick error check

# Install on xxx

# Open in IDE

Architecture
#

Second Brain concept:
Code base will grow to have these small domain like md files or some form of like Vectorized Memory that AI can use very quickly. So it doesn't have to parse the entire codebase every single time. It's essentially just a small compaction of context that is really available at all times for Claude code to use.  

Custom Workflows concept:
Once we have this like second brain and this real context that we have. A skill of Claude code is basically a saved workflow, a set of steps, and all of it is actually written by Claude itself. It's actually just a giant prompt in the MD file, but it's written in a way that Claude knows how to execute those steps every single time consistently.  
e.x. Every time I ship something, I need to write the same kind of post to let the people know that I had shipped something, what changed, how to test it, what to watch out for, how to get feedback. It's basically the same structure every single time. And to build this skill so that you don't have to ever manually write this again. You just actually do these steps manually with Claude just once, step by step. And then all you say is "Turn this into a skill I can reuse" . And now whenever we need to post something, as long as we have been working on the second brain for after every like work session. We can just trigger this skill and instantly. Claude will write into style we wanna to without reexplaining, reinfecting doing anything about like dragging and dropping. We just prompt it and we just have the content that we need to post. 
- Context is king. Context is best served fresh and condensed. 
- Let Claude code to manage context on our behalf.
- SEV investigation is a big part of our job

## Prompt
Update the project notes with what we worked on
Give me the latest status report
Split this PR into logical chunks
Turn this into a skill I can reuse
Tell me a good way to plan a live activity for when I background the app
This is a cool picture of the Clock Home mascot. Do something with it. 
Add this to my rules.
Hey, can you update that rule for me so we never do it again?
Use my Xcode MCP to build the app.
Audit my codebase and make sure that we're removing all of the audio playback and references to the audio of part of the xxx app. 
Save this to my local CLAUD.md in my project directory. Save the work that we just did. 
Load my context from my local projects. (Once we have second brain concept, we can say a command like this)
After every code change, validate the build succeeds.
Add debug logs, and run the app, and then control the emulator. (Then do the action we are trying to do). Read the logs, and debug that way. (Or we can use perfetto, hook into perfecto mcps, do a run, then have it read the traces and then see if it can find junk just like the timings. ) (For web, we could do like puppeteer and have claude navigate it using a /chrome command and then just actually do the navigation or have it write just test or have like integration end to end test.)
(To build a skill) Go and fetch hacker news for latest iOS news. 
	And then save a summary to my local claude directory
	Save what we just did into a new skill called "Fetch Hacker News."
		Why don't you extend this fetch Hacker News to fetch Twitter for Apple News? Find me a good Sigma MCP.
	Why don't you just install this for me? Spawn an iOS architecture agent, sub-agent, and do some investigation on my codebase and see if it's actually good or not.
Use what we just did to create an iOS architecture sub-agent.
Start working on my live activities feature.
All right, let's test out this iOS architecture and then just spawn a sub-agent.
Change the notification to ring a little sound when you finish execution.


```md
# TODO.md 

## Current Tasks
- Commit widget implementation changes (new files)
- Commit Live Activity and entitlements updates
- Commit music files deletions (~70 mp3s removed)
- Commit Models.swift and TimerViews.swift changes
- Decide on untracked config files (.claude/, .mcp.json, CLAUDE.md, downloads/)
- Validate build after all changes

## Settings
- Project: ark-tree
- Scheme: ark-tree
- Device: rocket

## Available Commands
- /build - Build for rocket
- /install - Install on rocket
- / audit - Run codebase audit
- /implement-feature - PRD-driven implementation

## Skills/Agents
- Live Activity expert
- Widget expert
- iOS architect
- SwiftUI specialist
- Swift reviewer

Tips
#

/init, 300 lines in CLAUD.md
/memory
Shift + tab (plan mode with new feature )
Escape + up/ give me something else
Double click Escape, then restore that context point
/help
/clear, to clear the context. Create new tab will bring up a new context as well. It’s good to start with a new feature and have completely done with the old task.
/context
/compact, to save some version of context into local second brain.
/model
/resume , recover the context
/mcp
Use templates for git
/rewind, to restore the code and the conversion(git is better than this)

CLAUD.md
#

Priority from top to bottom
Manually update rules: “Never do X” or “Always do Y.” Document mistakes here. Add to it whenever Claude makes a mistake you don’t want repeated.
Ask Claude to update rules: Say “add this to my rules” and Claude updates the file. Our CLAUDE.md becomes how we actually work.
Use workflow triggers: When user says deploy, run deploy script. This turns Claude into a workflow engine.
Compound Engineering: Commit CLAUDE.md to git: Teams gets instant access. They contribute back. Shared knowledge. Need to get rid of anything like generic for our code like file path and things like that. And we also want to be mindful how large this file becomes.
claude --dangerously-skip-permissions Dangerously-skip for throwaway eves: Docker container. Unpunished branch. If we can blow it away, let Claude run free.
/permissions

Daily workflow
#

Start features in Plan Mode: Shift + Tab twice. Claude can read but can’t execute. Explores without risk. Iterating with claude code. Arguing with it. Having a conversation with it. Really treating it like another just good engineer that I’m like working with and I never just like purely accept the first answers that it gives to me. I always kind of challenging it and I spent a lot of time and put a lot of effort at this stage of the development. Because I feel like once cloud code builds up that context and have a good execution specs, the generation of the code is actually the easy part. I love being in the zone and writing code. At least I used to. The thing is it’s really hard to get back into that mode. It’s like very different levels of abstractions of the way we’re working. (I gave the command and I go to the next one. I am building the context. I give it a command and I go to the other one. And then I give a command. So I end up like still can get into the zone, but it’s like a different style.)
Fresh context beats bloated. Less is more. When the context is full of dead ends, start a new session.
Persist before ending session. Sessions are temporary. CLAUD.md is permanent. This is long-term memory. “Save this to my local CLAUD.md in my project directory. Save the work that we just did.”
Lazy load context. Index at root pointing to subdirectory docs. Claude loads detail only when needed. “Load my context from my local projects. (Once we have second brain concept, we can say a command like this)”
Give verification commands. Test, lint, type check commands in CLAUDE.md. This 2-3x’s output quality.
Read thinking blocks. “I assume…” Or “I’m not sure…” = course-correct before Claude commits to wrong path.

Power User
#

Composability Framework

TA

Fri, 27 Mar 2026 23:20:36 -0400

Time
#

Jan 2022 - May 2022, Data structure & algorithms by Calvin Lin
Jan 2025 - May 2025, Advances in Deep Learning
May 2025 - Aug 2025, Advances in Deep Learning
Aug 2025 - Dec 2025, Natural Language Processing
Jan 2026 - Present, Advances in Generative Modeling

Grep

Sat, 08 Nov 2025 22:13:55 -0500

Alias for chekcing logs
#

alias grepless='grep --color=always "$@" | less -R'
# grepless "error" *.log

MEMO

Sat, 25 Oct 2025 17:21:05 -0400

pre-requisite
#

Extension Pack for Java (Microsoft)
Debugger for Java (usually included via the pack)
Also make sure VS Code is using your JDK (Java 17/21 etc):
Ctrl+Shift+P → Java: Configure Java Runtime
Ensure JAVA_HOME is set (System env) and matches what you want.

.vscode/tasks.json
#

{
  "version": "2.0.0",
  "tasks": [
    {
      "label": "boot:run (debug 5005)",
      "type": "shell",
      "command": "mvn -q -DskipTests spring-boot:run -Dspring-boot.run.jvmArguments=\"-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=127.0.0.1:5005\"",
      "options": {
        "cwd": "${workspaceFolder}"
      },
      "problemMatcher": []
    },
    {
      "label": "boot:run (normal)",
      "type": "shell",
      "command": "mvn -q -DskipTests spring-boot:run",
      "options": {
        "cwd": "${workspaceFolder}"
      },
      "problemMatcher": []
    }
  ]
}

.vscode/launch.json
#

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Attach to Spring Boot (5005)",
      "type": "java",
      "request": "attach",
      "hostName": "127.0.0.1",
      "port": 5005
    }
  ]
}

profile
#

mvn spring-boot:run ^
  -Dspring-boot.run.profiles=local ^
  -Dspring-boot.run.jvmArguments="-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=127.0.0.1:5005"

x
#

With 16GB RAM + big Java/Maven repo, your goal is: reduce file watching/indexing, cap Java language server, and avoid scanning build outputs. Do these in this order.

UV

Wed, 22 Oct 2025 22:49:34 -0400

1) What uv is (why use it)
#

Ultra-fast project/env manager—replaces python -m venv, much of pip, pip-tools, pipx, and parts of Poetry/pyenv workflows. It does envs, dependency locking, and tool running. (Astral Docs)

2) Install uv
#

macOS/Linux (user local): curl -LsSf https://astral.sh/uv/install.sh | sh
Windows (PowerShell): irm https://astral.sh/uv/install.ps1 | iex (These are from the official docs “Getting started”.) (Astral Docs)

3) Create & manage virtual environments
#

New env in .venv: uv venv
Named path: uv venv .venv-dev
Pick Python version: uv venv --python 3.11 (uv can download/resolve versions for you). (Astral Docs)
Project conventions: .venv holds the env; optional .python-version pins default Python for the project. (Astral Docs)

Note: You usually don’t activate the env. Instead, run commands inside it with uv run (next section). (Astral Docs)

Tar

Tue, 21 Oct 2025 22:58:48 -0400

The `tar` command — a practical, modern guide
#

Below is a tight-but-complete playbook you can actually use. Copy/paste the recipes; tweak paths as needed.

0) What `tar` is
#

tar = “tape archive”: it groups files/dirs into a single stream (“archive”).
It can also compress by delegating to gzip/bzip2/xz/zstd/etc.
Common archive suffixes: .tar (no compression), .tar.gz/.tgz, .tar.bz2, .tar.xz, .tar.zst, .tar.lz4.

1) The 5 core verbs
#

c = create
x = extract
t = list (table of contents)
r = append (to end; works only for uncompressed .tar)
u = update (append newer versions; also for plain .tar)

Always pair with f to name the archive file.

Springboot Exceptions

Sat, 18 Oct 2025 01:58:22 -0400

Great question. Here’s a pragmatic, Spring-friendly playbook for handling runtime exceptions cleanly and predictably.

1) Let them bubble to the right boundary
#

Don’t catch RuntimeException deep in your code unless you’re adding context or translating it.
Let it bubble to a well-defined boundary (controller, scheduled job, async worker) where you can convert it to:
- a meaningful HTTP error (for web APIs), or
- a log + metric + retry decision (for background work).
This keeps code simple, avoids double-logging, and preserves stack traces.

Rest Client

Thu, 09 Oct 2025 00:02:07 -0400

Github Repository
#

Rest Client

File Upload
#

POST http://localhost:3000/upload
Content-Type: multipart/form-data; boundary=boundary

--boundary
Content-Disposition: form-data; name="file"; filename="example.txt"
Content-Type: text/plain

< ./example.txt
--boundary

Spring Boot Exception

Tue, 09 Sep 2025 07:48:03 -0400

USER
#

in java 21, springboot 3, what’s the best practice to handle exception in projects

Thoughts
#

In Spring Boot 3, I’ll suggest using the ProblemDetail class (RFC7807) for structured error reports. Utilize @ControllerAdvice, @ExceptionHandler, and @RestControllerAdvice with logging (slf4j). Map exceptions to details like type, title, and status. While @ResponseStatus is still valid, consider customizing with WebMvcConfigurer for MVC and WebFlux.

NLP

Sat, 30 Aug 2025 11:38:12 -0400

Milestones
#

2013: Word2vec and N-grams
2014: RNN/LSTM
2015: Attention mechanism
2017: Large Pre-Trained Language Models (Transformers)
2018: BERT
2019: T5
2020: GPT-3

Magic

Wed, 20 Aug 2025 20:30:25 -0400

Magic: The Gathering

Terminology
#

Creature - A permanent type representing a living being. Sorcery - A spell type that is cast and then put into the graveyard. Summoning sickness - only affects creatures Tapped out - A state where a player has no untapped lands available to use for mana.

Flying - A keyword ability that allows a creature to avoid being blocked except by creatures with flying or reach. Touch death - A state where a creature with 0 toughness is put into the graveyard.

Rendercv

Tue, 19 Aug 2025 04:05:30 -0400

CLI
#

Rendercv CLI

rendercv new "Name" --theme "engineeringclassic"

rendercv render "xxx.yaml"

LC 2025

Sat, 16 Aug 2025 09:05:05 -0400

References
#

Problem List
#

Data Structures
#

Basic
#

1. Enumerate the right, maintain the left.
#

Core Concept: For two-variable problems like the two-sum where a_i + a_j = t:

BRE Drools

Sun, 13 Jul 2025 10:34:42 -0400

Syntax
#

📘 RULE STRUCTURE
────────────────────────────
rule "Rule Name"
when
  // CONDITIONS (LHS)
  $fact : Class(field == value)
  not(Class(field != value))
  exists(Class(field > 100))
  eval(customMethod($fact))
  accumulate(...)

then
  // ACTIONS (RHS)
  System.out.println($fact);
  modify($fact) { setField("new value") }
  insert(new Fact(...))
  retract($fact)
end

General Syntax of the when block
#

when
  // pattern
  $var: SomeFactType(field1 == "value", field2 > 10)

  // condition only (no binding)
  SomeOtherType(field3 matches "regex.*")

  // logical combinations
  eval(someJavaMethod($var))

  // negation, existence
  not(SomeType(...))
  exists(SomeType(...))

  // temporal logic (for CEP)
  EventA()
  EventB(this after[0s,10s] EventA())

Fact Pattern Matching

$person: Person(age > 18, name == "Alice")

Person: class name (fact type)
$person: variable binding (optional). You can refer to this in then.
age > 18, name == "Alice": field constraints (support most Java expressions)

Binding Variables

$amount: Order(amount > 1000)

Binds the Order fact to $amount so you can use it in the then block.

Order($value: amount)

This binds amount field to $value directly.

Logical Operators in Constraints

inside a pattern

Virtual Thread

Thu, 05 Jun 2025 21:10:40 -0400

Platform threads
#

Platform threads are the traditional threads provided by the operating system. They are managed by the OS and can be used to perform concurrent tasks. However, they can be resource-intensive and may lead to issues like thread contention and deadlocks.

Virtual threads
#

Virtual threads are a lightweight alternative to platform threads, introduced in Java 19 as a preview feature and made stable in Java 21. They are designed to be more efficient and easier to use for concurrent programming. Virtual threads are managed by the Java Virtual Machine (JVM) rather than the operating system, allowing for a large number of concurrent tasks without the overhead associated with platform threads. Virtual threads are created using the Thread.ofVirtual() method, and they can be used in the same way as platform threads. However, they are more efficient because they do not require a separate OS thread for each task. Instead, they use a small amount of memory and can be scheduled by the JVM to run on available platform threads.

Curl

Mon, 26 May 2025 21:09:13 -0400

Syntax
#

-X, –request, HTTP method to be used.
-i, –include, Include the response header.
-d, –data, Data to be sent in the API.
-H, –header, Any additional headers to be sent.

Api testing with Scripts
#

pip install pyyaml

- name: Get User
  method: GET
  url: https://api.example.com/users/{userId}
  path_params:
    userId: 123
  query_params:
    verbose: true
  headers:
    Authorization: Bearer <TOKEN>

- name: Create User
  method: POST
  url: https://api.example.com/users
  headers:
    Authorization: Bearer <TOKEN>
    Content-Type: application/json
  payload:
    name: John Doe
    email: john@example.com

import yaml
import json
import urllib.parse

def load_api_definitions(file_path):
    with open(file_path, 'r') as f:
        return yaml.safe_load(f)

def build_curl_command(api):
    method = api.get("method", "GET").upper()
    url = api["url"]

    # Replace path parameters
    if "path_params" in api:
        for key, value in api["path_params"].items():
            url = url.replace(f"{{{key}}}", str(value))

    # Add query parameters
    if "query_params" in api:
        query_string = urllib.parse.urlencode(api["query_params"])
        url += f"?{query_string}"

    curl_cmd = f"curl -X {method} '{url}'"

    # Headers
    headers = api.get("headers", {})
    for key, value in headers.items():
        curl_cmd += f" -H '{key}: {value}'"

    # Payload
    if "payload" in api and method in ["POST", "PUT", "PATCH"]:
        payload_str = json.dumps(api["payload"])
        curl_cmd += f" -d '{payload_str}'"

    return curl_cmd

def generate_curl_scripts(api_file_path, output_script_path):
    apis = load_api_definitions(api_file_path)
    with open(output_script_path, 'w') as f:
        f.write("#!/bin/bash\n\n")
        for api in apis:
            f.write(f"# {api.get('name', 'Unnamed API')}\n")
            curl_cmd = build_curl_command(api)
            f.write(curl_cmd + "\n\n")
    print(f"✅ Generated cURL script: {output_script_path}")

# Run the generator
if __name__ == "__main__":
    generate_curl_scripts("apis.yaml", "run_api_tests.sh")

#!/bin/bash

# Get User
curl -X GET 'https://api.example.com/users/123?verbose=true' -H 'Authorization: Bearer <TOKEN>'

# Create User
curl -X POST 'https://api.example.com/users' -H 'Authorization: Bearer <TOKEN>' -H 'Content-Type: application/json' -d '{"name": "John Doe", "email": "john@example.com"}'

Vscode

Wed, 05 Feb 2025 13:59:12 -0500

Attach Java Debugger
#

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "java",
      "name": "Attach to Spring Boot",
      "request": "attach",
      "hostName": "localhost",
      "port": 5005
    }
  ]
}

/*
mvn -Plocal spring-boot:run -Dspring-boot.run.jvmArguments="-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005"
*/

Vim setup
#

Press Ctrl + Shift + P (Cmd + Shift + P on Mac)
Type “Preferences: Open User Settings (JSON)”

    "vim.normalModeKeyBindingsNonRecursive": [
        {
        "before": ["g", "r"],
        "commands": ["references-view.findReferences"]
        },
        {
        "before": ["g", "R"],
        "commands": ["editor.action.referenceSearch.trigger"]
        },
        {
        "before": ["g", "d"],
        "commands": ["editor.action.revealDefinition"]
        },
        {
        "before": ["g", "D"],
        "commands": ["editor.action.revealDeclaration"]
        },
        {
        "before": ["g", "i"],
        "commands": ["editor.action.goToImplementation"]
        }
    ]

Restart VSCode or reload the window (Ctrl + Shift + P → “Developer: Reload Window”)

Spring Boot Session

Wed, 05 Feb 2025 07:22:27 -0500

Example
#

Result
#

common.Result

import lombok.Data;

@Data
public class Result {
    private Integer code;
    private String message;
    private Object data;
    
    protected Result(Integer code, String message, Object data) {
        this.code = code;
        this.message = message;
        this.data = data;
    }
    
    public static Result OK() {
        return new Result(200, null, null);
    }
    
    public static Result success(Object data) {
        return new Result(200, null, data);
    }
    
    public static Result success(String message, Object data) {
        return new Result(200, message, data);
    }
}

BackgroundController
#

controller.BackgroundController

nvm

Sun, 02 Feb 2025 00:11:41 -0500

// install node with version
nvm install 22.13.1

// set default node version
nvm alias default 16.13.0

// verify
node -v

Redis

Wed, 22 Jan 2025 23:53:20 -0500

SETNX
#

The SETNX command in Redis stands for SET if Not eXists. It is used to set a key to a value only if the key does not already exist. This operation is atomic, which means it ensures that no race conditions occur when multiple clients attempt to execute the command simultaneously.
syntax: SETNX key value

Parameters:
#

key: The name of the key to set. value: The value to associate with the key if it does not already exist.

Github Actions

Sat, 11 Jan 2025 23:35:19 -0500

File Structure
#

.github/workflows/**.yml: Github Actions workflow files

Example
#

name: workflow Name # workflow name
on: push # trigger event

permissions: # to avoid bugs when add fake-deploy step
  contents: write

jobs: # define jobs, jobs are running in parallel
  npm-build: # random job name
    name: npm build job # job name
    runs-on: ubuntu-latest # runner
    
    steps: # define steps, steps are running in sequence
      - name: get code from github # step name
        uses: actions/checkout@v4 # action
        
      - name: group steps together with vertical bar # step name
        run: |
          npm install
          npm run build
        
      - name: fake-deploy # step name 
        uses: JamesIves/github-pages-deploy-action@4 # action
        with: # action input
          branch: gh-pages # branch name
          folder: build # artifact folder

Docker Example
#

auto generate Docker Image and push to Docker Hub

create a docker hub repository with namereact-app
New Access Token in Docker Hub

FROM node:18-alpine

WORKDIR /react-app

COPY public/ /react-app/public/
COPY src/ /react-app/src/
COPY package.json /react-app/package.json

RUN npm install

CMD ["npm", "start"]

name: Generate Docker Image and Push to Docker Hub 
on: push 

jobs: 
  npm-build: 
    name: npm build job name
    runs-on: ubuntu-latest 

    steps: 
      - name: get code from github 
        uses: actions/checkout@v4 

      - name: login to docker hub
        uses: docker/login-actiion@v3
        with: 
          username: ${{ secrets.DOCKER_USERNAME }} # github -> Security -> Secrets and variables -> Action
          password: ${{ secrets.DOCKER_PASSWORD }}
      - name: build docker image and push to docker hub
        uses: docker/build-push-action@v5
        with: 
          push: true
          tags: ${{ secrets.DOCKER_USERNAME }}/react-app:latest # tag here must be the same as the repository name in Docker Hub

IDEA

Sat, 11 Jan 2025 20:19:11 -0500

Intellij SpringBoot DevTools Setup
#

Add spring-boot-devtools in pom.xml
Settings - Build,Execution,Deployment - Compiler, enable Build project automatically
Settings - Advanced Settings, enable Allow auto-make to start even if developed application is currently running
Disable cache on browser

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>
</dependency>

spring.devtools.restart.enabled=true
spring.devtools.restart.additional-paths=src/main/java
spring.devtools.restart.exclude=WEB-INF/**

Debug
#

Line Breakpoint (red circle)
#

Condition: must put a expression returns a boolean
Stream: Trace Current Stream Chain
Force Return: Debug Window -> Debugger -> Function Name(right click) -> Force Return
Throw Exception: same as above
Multi Thread: Right click break point -> Enable Suspend with Thread

Method Breakpoint (red diamond)
#

Most of time use in Java interface

Field Watchpoint (red eye)
#

Exception Breakpoint (red thunder)
#

Manually add Java Exception Breakpoints

ideaVim
#

diw
di"
ciw
ci"

cit // delete within tag

dt> // delete to >
ct> // delete to >

Nx

Sun, 01 Dec 2024 00:55:44 -0500

helper
#

npx nx list @nx/angular

useful properties and tips
#

--dry-run
--skip-tests
@nx/angular:xxx is optional, we can directly use xxx, and then choose.

generate monorepo project
#

npx create-nx-workspace@latest monorepo-name --preset=angular-monorepo

generate app
#

npx nx g app apps/app-name

generate component/directive/pipe/service
#

npx nx g c|d|p|s full-path --skip-tests

generate library
#

npx nx g lib libs/lib-name

NX Angular MFS
#

npx create-nx-workspace@latest ng-mf --preset=apps

cd ng-mf
npx nx add @nx/angular

npx nx g @nx/angular:host apps/dashboard --prefix=ng-mf

npx nx g @nx/angular:remote apps/login --prefix=ng-mf --host=dashboard

CSS

Fri, 15 Nov 2024 14:05:16 -0500

#

Temp

Mon, 11 Nov 2024 15:23:41 -0500

const express = require("express");
const cors = require("cors");

const app = express();
const PORT = 3000;

// Enable CORS for cross-origin requests
app.use(cors());

// Middleware to parse JSON requests
app.use(express.json());

// Mock data
const mockData = {
  page: "1",
  total: "18",
  records: "342",
  summaries: [
    {
      ptsTransferRqstID: "506327",
      id: "1",
      fromIssuer: {
        issuerId: "3663",
        issuerName: "M&T BANK",
      },
      toIssuer: {
        issuerId: "1555",
        issuerName: "GUILD MORTGAGE COMPANY",
      },
      gmpUserId: "I_twu23663",
      ptsTransferRqstTyp: "Standard-Partial",
      ptsTrnsfrRqstDt: "12/01/2024",
      ptsSaleDt: "11/21/2024",
      ptsTransferRqstStatus: "Validation with Errors",
      ptsTransferRqstCode: "PVF",
      ptsBuyerSellerFlag: "S",
      rowCount: 342,
      rowNum: 1,
      assAgreementDocId: null,
      appLetterDocId: null,
      hecmIssrFlag: "N",
    },
  ],
};

// Define API endpoint
app.get("/pts/services/v1/transfers", (req, res) => {
  // Extract query parameters (optional)
  const {
    issuerId,
    page = "1",
    sellingIssuer,
    buyingIssuer,
    transferType,
    transferDate,
    transferStatus,
    transferNumber,
  } = req.query;

  console.log("Query Parameters:", req.query);

  // Return the mock data
  res.json(mockData);
});

// Start the server
app.listen(PORT, () => {
  console.log(`Mock server is running at http://localhost:${PORT}`);
});

Windows

Mon, 04 Nov 2024 08:17:49 -0500

Find and Kill process
#

netstat -ano | findstr :4200
taskkill /PID <PID> /F

Ginnie Mae

Thu, 05 Sep 2024 23:04:41 -0400

What
#

Mission
#

Ginnie Mae’s guaranty links the United States housing market to the global financial markets, ensuring sustainability, affordability, and liquidity.

Goal
#

Ensuring affordable mortgage especially for low-income and first-time homebuyers.

How
#

providing consistent access to capital for mortgage lenders, which allows them to offer lower interest rates to borrowers.

Tailwind

Wed, 04 Sep 2024 19:21:48 -0400

Youtube

Angular NgRx

Wed, 04 Sep 2024 19:21:00 -0400

Tips
Youtube

Pros
#

The component shouldn’t have to worry about how to manage the state when something happens.
It doesn’t need to know what services to inject or methods to call to get the job done.

Work flow
#

A component dispatches an action to indicate that something happened.
The part of our application actually responsible for determining how actions should modify state are the reducers.
Reducers detect all of the actions being dispatched in the app and determine how the state should be modified as a result.
Usually we would have a reducer for each feature or entity in the app.
Reducers detect the action, take the current state and store the new state in the store.
So the store which is often global is where all of the state for our application lives.
Store is really just one big object full of data.
When a component wants to use some of that state from the store. Component can use a selector to pull in the state that it needs from the store.
Effects, an important concept is that effects reduces the functions that take in an action and create a new state are pure functions. That means two thing:
1. Given the same input, they will always produce the same output.
2. Pure functions should also not create any side effects.

So when an action is dispatched, it needs to be immediately handled by the reducer. And the state will be changed based on just the data immediately available to that action. That means for us is that when we dispatch an action, we need to give it all of the data that the reducer needs to make the state modification immediately. We cannot be making asynchronous calls to go load in data from a server for example.

AWS CDK

Sat, 17 Aug 2024 20:16:40 -0400

Common Usage
#

npm install -g aws-cdk
cdk --version

cdk init app --language typescript

npm install @aws-cdk/aws-dynamodb

cdk synth

cdk deploy

Aws Sam

Fri, 16 Aug 2024 23:20:46 -0400

Common Use Case
#

sam build
sam deploy --guided

sam local start-api

Prompts

Thu, 15 Aug 2024 16:45:00 -0400

Resume bullet points
#

how to convert my the following description into one sentence that I can use in resume: "> Managed Kubernetes Cluster, meaning AWS will manage the **Master Nodes** for us. It will create the master nodes. Install all the necessary applications on them, like **Container Runtime**, Kubernetes **Master Processes**. It will take care of scaling it when needed, doing backup on that, etc. If you have small team of people, usually it's a good idea to let the platform do this maintenance for you. So we can focus on deploying your applications in K8s without worrying about whether the master nodes are properly backed up etc. This means we only have to care about the worker nodes.

> **we will have a control plane once AWS creates all master nodes**(by choosing cluster name, k8s version, choose region and VPC, set Security Group for the cluster). 
> **Then, we have to create worker nodes and connect to the cluster**(by creating Node Group, and choose the cluster it attaches to, define Security Group, select instance type of EC2 instances, basically which resources your EC2 instances should have, etc.). On AWS these worker nodes will be some EC2 instances with certain CPU RAM and Storage Resources. With Node Group, we should have auto-scaling. So based on the cluster needs, depend on how much load the cluster has, the new worker nodes will automatically be added or removed in the cluster. So for that we should define max and min number of nodes, and we have some other configurations as well.
> **Finally connect to the cluster from local machine,** to deploy our applications from laptop using kubectl, which is k8s command line tool. It basically uses configured kubectl to talk to remote cluster."

please give me 2 descriptions that I can use in resume for ELK experience.

Api Design

Thu, 15 Aug 2024 01:40:31 -0400

no trailing forward slash
hierarchical relationships
use hyphens
no actions
use plurals
avoid complexity

Api Security

Thu, 15 Aug 2024 01:07:10 -0400

Input Validation and Sanitization
Monitoring and Logging
Data Encryption
Regular Database Audits
Penetration Testing
Authentication and Authorization

JWT
#

Secure Client Storage
- To avoid XSS, CSRF
Token Expiration
Validate

Linkedin Del

Thu, 08 Aug 2024 22:17:43 -0400

Engineer Manager My team manages the core infrastructure for CarRentals.com for the transaction (booking, payment, finance) and pricing areas. We manage 12 microservices (java, php) deployed in AWS, using AWS technologies like SQS, dynamoDB, elasticCache, SNS, ELB, EC2, serverless framework. We are tackling big challenges even if we are a small team. But the philosophy of the team : quality first scalability knowing perfectly the business to deliver better features always search for the best technology always even if it unknown for you and we will have to learn, together innovate, modernize don’t be afraid if we have to work on huge changes or if you want to propose huge changes the team is here to support you hiring the right persons : skills but not only, team fitting, communication, humbleness, humour

this philosophy allows us to succeed, to deliver in time and with a high quality. Maybe not always the best quality we wanted because of deadlines and resources we have but the quality to maintain our business and reduce our support.

Hiring Manager Interview

Mon, 05 Aug 2024 21:54:07 -0400

My advantages
#

I have a proven track record of problem-solving.
I can analyze data to develop real-life engineering solution.
I possess excellent communication skills.
My attitude to work.
My attention to details skills.
My commitment to the organization.
My advantage, I am passionate about engineering and I take responsibility for my own continuous learning and development.

Greetings
#

Good evening!
Thank you for taking the time to meet with me today.
I appreciate the opportunity to speak with you and discuss how I can contribute to your team.
I’m excited for our conversation.

General Questions
#

Why are you interested in this role?
#

The project is focusing on Java Backend, and Microservice Architecture, and AWS
That aligns with my experience and interests.

What do you know about our company?
#

I know that Expedia is a leader in [online travel industry], providing [hotel bookings, flight reservations, car rentals, and so on].

Why are you leaving your current job?
#

I have enjoyed my time at my current job and learned a lot, but I am looking for new challenges and opportunities to grow.
And additionally, my current project is about to end.
So I need to switch to a new project.

Where do you see yourself in five years?
#

In five years, I see myself as a senior backend developer, having contributed to several successful projects and having taken on more responsibilities.
I am committed to continuous learning and hope to keep expanding my skills in new technologies and methodologies.

Role-Specific Questions
#

What interests you about this particular role?
#

This role excites me because it involves working on scalable and high-performance systems using technologies I am passionate about, such as Spring Boot and microservices architecture.
I am eager to apply my expertise in developing robust backend solutions to help the team achieve its goals.

How do your skills and experiences align with the requirements of this job?
#

My experience with Java, Spring Boot, and microservices architecture aligns well with the key requirements of this role.
I have a proven track record of designing and implementing scalable backend systems, and I am confident that my problem-solving skills and ability to work in a collaborative environment will be valuable assets to your team.

Can you describe a typical day in your current/previous role?
#

A typical day involves reviewing and writing code, participating in stand-up meetings, collaborating with front-end developers and other team members, and troubleshooting any issues that arise.
I also spend time optimizing code for performance, conducting code reviews, and ensuring the systems are running smoothly.

What key skills do you think are necessary for this position?
#

Key skills include a deep understanding of core Java, experience with Spring Boot and microservices, strong problem-solving abilities, and familiarity with database technologies like SQL and NoSQL.
Additionally, effective communication and teamwork are crucial for collaborating with other developers and stakeholders."

Behavioral Questions
#

Can you describe a challenging situation you faced at work and how you dealt with it?
#

In a previous project, we faced a challenge with a critical service that was experiencing frequent downtime.
I took the initiative to investigate the issue, identified that it was due to a memory leak, and implemented a fix by optimizing the resource management in the code.
I also set up monitoring and alerting to catch similar issues in the future.
This proactive approach helped stabilize the service and improved its reliability.

Tell me about a time you had to work closely with a difficult colleague. How did you handle it?
#

I once worked with a colleague who had a different approach to problem-solving, which led to some friction.
I decided to have a candid conversation to understand their perspective and find common ground.
We agreed on a collaborative approach where we would openly discuss our ideas and find the best solution together.
This improved our working relationship and resulted in more effective teamwork.

Describe a situation where you had to meet a tight deadline. How did you manage your time?
#

In a recent project, we had a tight deadline to deliver a new feature requested by a key client.
I prioritized my tasks, broke down the work into manageable chunks, and set clear milestones.
I also collaborated closely with my team to ensure we were all aligned and on track.
By staying focused and maintaining open communication, we were able to meet the deadline successfully.

Can you give an example of a project where you took the lead?
#

I led a project to migrate our legacy system to a microservices architecture.
I was responsible for planning the migration, designing the new system, and coordinating the work across different teams.
I conducted regular meetings to ensure everyone was on the same page and addressed any issues promptly.
The project was completed on time and resulted in improved system performance and maintainability.

How do you prioritize tasks when you have multiple deadlines?
#

I prioritize tasks based on their urgency and impact on the project.
I use tools like Jira to keep track of tasks and deadlines.
I also communicate with stakeholders to understand their priorities and ensure that the most critical tasks are addressed first.
By staying organized and focusing on high-priority items, I manage to meet multiple deadlines effectively.

Tell me about a time you made a mistake at work. How did you handle it?
#

I once deployed a code change that caused a critical service to fail.
I immediately took responsibility, rolled back the change, and informed my team and stakeholders.
I then investigated the root cause, fixed the issue, and implemented additional testing to prevent similar mistakes in the future.
This experience taught me the importance of thorough testing and effective communication during incidents.

How do you handle feedback and criticism?
#

I view feedback and criticism as opportunities for growth.
I listen carefully, ask clarifying questions if needed, and reflect on how I can improve.
I also seek feedback proactively to understand how I can better meet expectations.
By maintaining a positive attitude and being open to learning, I continuously improve my skills and performance.

Team and Culture Fit Questions
#

How do you handle working in a team environment?
#

I thrive in a team environment where collaboration and open communication are valued.
I believe in sharing knowledge, supporting my teammates, and contributing to a positive work culture.
I enjoy working with diverse teams and leveraging each team member’s strengths to achieve our common goals.

Describe your ideal work environment.
#

My ideal work environment is one that promotes collaboration, innovation, and continuous learning.
I appreciate a culture where feedback is encouraged, and team members are empowered to take initiative.
I also value a healthy work-life balance and a supportive atmosphere where everyone feels respected and valued.

How do you handle conflicts within a team?
#

I believe in addressing conflicts openly and constructively.
I listen to all perspectives, seek to understand the underlying issues, and work towards finding a mutually agreeable solution.
By fostering open communication and focusing on the common goals, I help ensure that conflicts are resolved amicably and do not impact the team’s productivity.

What do you think is most important for fostering a positive team environment?
#

Open communication, mutual respect, and a shared commitment to the team’s goals are crucial for fostering a positive team environment.
Encouraging collaboration, celebrating successes, and supporting each other through challenges help build a strong and cohesive team.

How do you approach collaboration with remote team members?
#

I ensure effective collaboration with remote team members by leveraging communication tools like Slack and Zoom for regular check-ins and updates.
I also use project management tools like Jira to keep everyone aligned and informed.
Building trust and maintaining clear communication are key to successful remote collaboration.

Problem-Solving and Analytical Questions
#

Can you describe a complex problem you solved and how you approached it?
#

In a previous project, we faced a complex issue with data synchronization between two services.
I analyzed the problem, identified the root cause, and designed a solution using event-driven architecture to ensure reliable data synchronization.
I implemented the solution, tested it thoroughly, and monitored its performance to ensure it worked as expected.
The solution improved data consistency and system reliability.

How do you approach troubleshooting and debugging technical issues?
#

I approach troubleshooting systematically by first understanding the problem and gathering relevant information.
I review logs and error messages to identify potential causes.
I then use debugging tools to isolate and investigate the issue.
Once identified, I implement a fix and conduct thorough testing to ensure the problem is resolved.
I also document the issue and solution for future reference.

What steps do you take to ensure your code is of high quality?
#

I follow best practices such as writing clean and maintainable code, conducting code reviews, and implementing unit tests.
I also use static code analysis tools to identify potential issues early.
Additionally, I adhere to design principles like SOLID and ensure my code is well-documented.
Continuous learning and staying updated with the latest best practices help me maintain high code quality.

Describe a situation where you had to quickly learn a new tool or technology. How did you do it?
#

In a recent project, I had to quickly learn Docker for containerizing our applications.
I started by reading the official documentation and tutorials to understand the basics.
I then set up a local development environment and experimented with creating and managing containers.
I also sought advice from colleagues with Docker experience and participated in online forums.
Within a few weeks, I was able to effectively use Docker for our project.

Leadership and Initiative Questions
#

Have you ever taken the initiative to improve a process at work?
#

Yes, I noticed that our deployment process was manual and error-prone, leading to frequent downtime.
I took the initiative to implement a CI/CD pipeline using Jenkins, which automated the build, test, and deployment processes.
This significantly reduced deployment time and errors, leading to more stable and reliable releases.

Can you give an example of a time you mentored or coached a colleague?
#

I mentored a junior developer who was new to our team.
I provided guidance on coding standards, best practices, and our development workflow.
I also conducted regular code reviews and offered constructive feedback.
Over time, the junior developer became more confident and productive, contributing effectively to our projects.

How do you motivate yourself and others on your team?
#

I stay motivated by setting clear goals and continuously challenging myself to learn and improve.
To motivate my team, I ensure open communication, recognize and celebrate achievements, and provide support during challenges.
Creating a positive and collaborative environment where everyone feels valued helps keep the team motivated.

Describe a situation where you had to persuade others to follow your idea.
#

In a project, I proposed migrating our monolithic application to a microservices architecture to improve scalability and maintainability.
Some team members were hesitant due to the perceived complexity and risks.
I presented a detailed plan, highlighting the benefits and addressing their concerns.
I also suggested a phased approach to mitigate risks.
My proposal was eventually accepted, and the migration led to significant improvements in our system’s performance and flexibility.

Questions for the Hiring Manager
#

Can you describe the team I would be working with?
#

What are the biggest challenges the team is currently facing?
#

How do you measure success for this role?
#

What does a typical career path look like for someone in this position?
#

Can you tell me about the company culture?
#

What are the next steps in the interview process?
#

Keyword Structure

Fri, 02 Aug 2024 08:01:54 -0400

I
#

worked
focus
build
design
implement
optimize
utilize
developed
handle
manage
use
ensure
have (deep understanding of XXX concept)
have (experience with XXX tools and frameworks)
am proficient in (using)

XXX Experience
#

equipped (me with skills to deliver XXX solutions)

Tools
#

provide
allows
helps

Approach
#

starts with
understanding
set
also use

Do You Have Experience

Fri, 02 Aug 2024 07:33:49 -0400

Java
#

Yes, I have extensive experience with Java, having worked as a Java developer for over six years. During this time, I have primarily focused on backend development and building robust microservice architectures.

In my current role, I have been involved in various projects where I designed and implemented scalable and efficient solutions using core Java concepts and popular frameworks. For instance, in a recent project, I developed a data analytics dashboard where I utilized Java in conjunction with Spring Boot to create RESTful APIs, handle business logic, and manage database interactions using Hibernate and JPA.

Goldman

Mon, 29 Jul 2024 23:56:52 -0400

3-5 years of strong programming skills in Java with proficiency in object-oriented design principles Experience with Java frameworks such as DropWizard, Spring, and Hibernate Familiarity with web development frameworks (Angular or React) Familiarity with distributed storage systems like DB2, Oracle, Cassandra, MongoDB Familiarity with continuous integration and continuous deployment (CI/CD) pipelines, especially using Git Working knowledge of Unix/Linux environments

OOD principles
#

Encapsulation Example: “Encapsulation involves bundling the data (attributes) and methods (functions) that operate on the data into a single unit, or class, and restricting access to some of the object’s components. In my projects, I’ve used encapsulation to ensure that an object’s internal state cannot be altered directly from outside the class, which helps maintain data integrity.”

Reach Out Letter

Mon, 29 Jul 2024 20:05:05 -0400

DS
#

Data Scientist Role at Disney: Passionate Data Scientist with Strong Technical Background

Hi Chrissy,

Hope you're doing great! I noticed that you currently work at The Walt Disney Company, and I'm excited to learn about the Data Scientist II role you're recruiting for.

With a Master of Science degree from UT Austin and a strong background in computer science, I have 6 years of 
experience building practical machine learning solutions using Python, statistical modeling, and data analysis. My 
highly relevant skills include Data Analytics, Hive, and Computer Science.

Disney's mission to create unforgettable content experiences resonates with me, as someone who is passionate about 
innovation and driven by data-driven solutions.

Is this role still available? Thank you!

Best regards,

DS
#

Interested in the Senior Marketing Data Scientist, CRM & Governance role at Peloton

Hi Jordan,

Hope you're having a great day! I noticed you work at Peloton and wanted to learn more about the Senior Marketing 
Data Scientist, CRM & Governance role. My background in 5 year data science and visualization aligns well with the 
analytical experience required for this position.

Peloton's connected fitness ecosystem is impressive, and I'm excited to use my skills to contribute towards your 
mission. Is this opportunity still available?

Thank you,

DS
#

Analytics Engineer (L5) - Messaging - Inquery and Interest

Hi Mallory,

I am Yixian, a data scientist with 5 years of experience. I was impressed by your recruting experience at Netflix.

I am highly interested in the Analytics Engineer (L5) - Messaging role. I have expertise in bridging the gap between 
technical and business teams, ensuring actionable and interpretable data. My skills include SQL, Python, Scala, AWS, 
Airflow, dbt, Hadoop, Hive, Spark, and Tableu. I am also an AWS Certified Solution Architect - Associate (SAA).

Could we schedule a call this week to discuss this opportunity further?

Thanks,

#

Glider

Mon, 22 Jul 2024 12:03:13 -0400

String Segmentation
#

class Outcome {
  public static String solve(String s, List<String> wordDict) {
    Set<String> hs = new HashSet<>(wordDict);
    boolean[] f = new boolean[s.length() + 1];
    f[0] = true;
    for (int i = 1; i <= s.length(); i++) {
      for (int j = 0; j < i; j++) {
        if (f[j] && hs.contains(s.substring(j, i))) {
          f[i] = true;
          break;
        }
      }
    }
    return f[s.length()] ? "true" : "false";
  }
}

Little Brother’s Factorial Challenge
#

class Outcome {
  public static List<Integer> solve(int m, int n) {
    if (n < m) return new ArrayList<Integer>();
    List<Integer> result = new ArrayList<Integer>();
    BigInteger[] factorials = new BigInteger[n + 1];
    factorials[0] = BigInteger.ZERO;
    factorials[1] = BigInteger.ONE;
    for (int i = 2; i <= n; i++) {
      factorials[i] = BigInteger.valueOf(i).multiply(factorials[i - 1]);
    }
    for (int i = m; i <= n; i++) {
      if (isEven(factorials[i])) result.add(i);
    }
    return result.isEmpty() ? Arrays.asList(0) : result;
  }

  private static boolean isEven(BigInteger i) {
    return (i.toString().charAt(0) - '0') % 2 == 0;
  }
}

Brother’s Game
#

class Outcome {
  public static int solve(List<Integer> nums) {
    int n = nums.size();
    int[] f1 = new int[n];
    int[] f2 = new int[n];
    int[] f3 = new int[n];
    f1[0] = nums.get(0) ^ 1;
    f2[0] = nums.get(0);
    f3[0] = nums.get(0);
    int result = 0;
    for (int i = 1; i < n; i++) {
      f1[i] = Math.max(f1[i - 1] + 
         (nums.get(i) ^ 1), f3[i - 1] + (nums.get(i) ^ 1));
      f2[i] = Math.max(f1[i - 1] + nums.get(i), f2[i - 1] + nums.get(i));
      f3[i] = f3[i - 1] + nums.get(i);
      result = Math.max(result, Math.max(f1[i], f2[i]));
    }
    return result;
  }
}

Binary Addition
#

class Outcome {
  public static String solve(String a, String b) {
    StringBuilder sb = new StringBuilder();
    int i = a.length() - 1, j = b.length() - 1;
    int carry = 0;
    while (i >= 0 || j >= 0 || carry == 1) {
      if (i >= 0) {
        carry += a.charAt(i--) - '0';
      }
      if (j >= 0) {
        carry += b.charAt(j--) - '0';
      }
      sb.append(carry % 2);
      carry = carry / 2;
    }
    return sb.reverse().toString();
  }
}

Biggest Rectangle
#

class Outcome {
  public static int maxArea(List<Integer> b) {
    Deque<Integer> q = new ArrayDeque<Integer>();
    int result = 0;
    for (int i = 0; i <= b.size(); i++) {
      int curr = i == b.size() ? 0 : b.get(i);
      while (!q.isEmpty() && b.get(q.peekLast()) > curr) {
        int h = b.get(q.pollLast());
        int l = q.isEmpty() ? 0 : q.peekLast() + 1;
        result = Math.max(result, (i - l) * h);
      }
      q.offerLast(i);
    }
    return result;
  }
}

LRU
#

class Outcome {
  private int capacity;
  LinkedHashMap<Integer, Integer> LRU = new LinkedHashMap<>();

  public Outcome(int capacity) {
    this.capacity = capacity;
  }

  public int get(int key) {
    if (!LRU.containsKey(key)) {
      return -1;
    }
    updateRecent(key);
    return LRU.get(key);
  }

  public void put(int key, int val) {
    if (LRU.containsKey(key)) {
      LRU.put(key, val);
      updateRecent(key);
      return;
    }
    if (LRU.size() >= this.capacity) {
      int oldestKey = LRU.keySet().iterator().next();
      LRU.remove(oldestKey);
    }
    LRU.put(key, val);
  }

  private void updateRecent(int key) {
    int val = LRU.get(key);
    LRU.remove(key);
    LRU.put(key, val);
  }

  public static List<Integer> solve(int capacity, List<String> ar) {
    Outcome LRU = new Outcome(capacity);
    List<Integer> result = new ArrayList<>();
    for (String Operation : ar) {
      String[] parts = Operation.split(",");
      if (parts[0].equals("PUT")) {
        int key = Integer.parseInt(parts[1]);
        int value = Integer.parseInt(parts[2]);
        LRU.put(key, value);
      } else if (parts[0].equals("GET")) {
        int key = Integer.parseInt(parts[1]);
        result.add(LRU.get(key));
      }
    }
    return result;
  }
}

LeetCode 75

Sat, 20 Jul 2024 09:19:43 -0400

Array / String
#

Two Pointer
#

Sliding Window
#

Prefix Sum
#

HashMap / Set
#

Stack
#

Queue
#

Linked List
#

Binary Tree - DFS
#

Binary Tree - BFS
#

Binary Search Tree
#

Graph DFS
#

Graph BFS
#

Heap / Priority Queue
#

Binary Search
#

Backtracking
#

DP - 1D
#

DP - Multidimensional
#

Bit Manipulation
#

Trie
#

Intervals
#

Monotonic Stack
#

Resume Parts

Wed, 10 Jul 2024 17:42:52 -0400

Prompt
#

how to convert my the following description into one sentence that I can use in resume: 
"Managed Kubernetes Cluster, meaning AWS will manage the Master Nodes for us. It will create the master nodes. Install all the necessary applications on them, like Container Runtime, Kubernetes Master Processes. It will take care of scaling it when needed, doing backup on that, etc. If you have small team of people, usually it's a good idea to let the platform do this maintenance for you. So we can focus on deploying your applications in K8s without worrying about whether the master nodes are properly backed up etc. This means we only have to care about the worker nodes.
we will have a control plane once AWS creates all master nodes**(by choosing cluster name, k8s version, choose region and VPC, set Security Group for the cluster). 
Then, we have to create worker nodes and connect to the cluster(by creating Node Group, and choose the cluster it attaches to, define Security Group, select instance type of EC2 instances, basically which resources your EC2 instances should have, etc.). On AWS these worker nodes will be some EC2 instances with certain CPU RAM and Storage Resources. With Node Group, we should have auto-scaling. So based on the cluster needs, depend on how much load the cluster has, the new worker nodes will automatically be added or removed in the cluster. So for that we should define max and min number of nodes, and we have some other configurations as well.
Finally connect to the cluster from local machine, to deploy our applications from laptop using kubectl, which is k8s command line tool. It basically uses configured kubectl to talk to remote cluster."

please give me similar description that I can use in resume for XXX experience

Java
#

DropWizard
#

Developed and maintained RESTful web services using DropWizard, ensuring high performance and scalability by implementing efficient resource management and optimization techniques.
Led the integration of DropWizard with various backend systems, enhancing system reliability and simplifying deployment processes through robust configuration management and monitoring.

Spring Boot
#

Spring MVC
#

Spring Security
#

Spring Data JPA
#

Hibernate
#

Kafka
#

Junit
#

TestNG
#

Selenium
#

Cucumber
#

Jmeter
#

Log4J
#

Splunk, Logstash, Kibana
#

SonarQube
#

Maven
#

Tomcat
#

SOAP
#

JWT
#

Oauth2
#

J2EE (Java Servlets, JDBC)
#

Restful Web Services
#

Microservice
#

DataDog
#

Dynatrace
#

Postman
#

AWS
#

Compute
#

EC2 (Elastic Compute Cloud)
#

Understand EC2 instance types, pricing models, Auto Scaling, and best practices.

NOTE

Mon, 08 Jul 2024 01:53:42 -0400

Study Plan 2024
#

Language
#

Java: Backend, Spring
Typescript: Angular
Go: Backend
Python: Kaggle
C++: CUDA

Long
#

Leetcode

https://leetcode.com/problemset/

OOD, System Design

https://www.designgurus.io/course-play/grokking-the-object-oriented-design-interview/doc/637d2288eeb90d2166ac95be

Focus
#

Java
SpringBoot
Angular

Note
#

merge sort
quick select
union find
segment tree
binary index tree
strongly connected component
shortest path
monotonic queue

Kafka

Thu, 04 Jul 2024 04:54:15 -0400

Bugs

Mon, 01 Jul 2024 21:32:39 -0400

K8s

Sun, 30 Jun 2024 21:46:13 -0400

Various container runtimes
#

Kubernetes is responsible for scheduling pods.
Container runtimes manage the containers which make up these pods. The Container Runtime Interface (CRI) allows Kubernetes to use any CRI-compliant runtime.

Self Introduction

Wed, 26 Jun 2024 17:02:29 -0400

1. Self Introduction
#

My name is Austin. I have been working as a Java developer for over 6 years, and primarily focusing on Backend Development, and the MicroService architecture.

My expertise basically like the core java concept, and (I am) familiar with those popular frameworks such as Spring Boot, Spring MVC, Spring Security, Spring Data JPA, Hibernate, Kafka, JUnit, and so on. And for front-end, I have experience using React and also Angular. I also have hands-on experience on building robust MicroService architecture with AWS cloud.

Project Design Doc

Mon, 24 Jun 2024 22:33:18 -0400

Guide
#

please write down design document for your most recent project, including:
1. features / functionalities / system purpose + overview
2. database schema (tables)
3. high level design (microservice architecture) and provide module pictures
4. rest api design (design 2 - 4 rest apis)
5. Data flow, prepare 2 - 3 data flow diagram (example: when user client some buttons to upload some files, what happens next, how does request go through your service

Design Doc of eBay project - Data Analytics Dashboard
#

1. Features / Functionalities / System Purpose + Overview
#

Dashboard
#

Requirements
#

there is an analytical dashboard
it has a ton of widgets

Out of Scope
#

write operations
- there may have been some kind of “generate report” button

Numbers
#

1000 TPS reads

Approaches
#

Rendering approaches:
#

client-side rendering

Interview Projects

Sat, 22 Jun 2024 21:08:17 -0400

Guide
#

Project Preparation Guide
#

Company Info.
- Brief company info.
Project Name.
- Why the project exists? What’s the main goal?
Users.
- The project is used by whom? How many users approximately?
What’s the team structure.
- Agile Team (Scrum Master, Product Owner, Manager, Team Lead, Developers, QA, BA, DBA, DevOps)
What’s agile scrum flow?
- Daily meetings, Jira, Planning meeting, demo, review, retrospective
Your Main responsibilities.
- Design, Implement, Test XXX functions, Backend, DB, Frontend?
High-level System Structure
1. TechStack
2. Environments
3. Cloud/Platform
4. Architecture
One Specific Functionality.

High-Level System Structure Guide
#

TechStack
- Java version, SpringBoot, REST, What kind of DB, AWS(Cloud), React/Angular, Junit, Mockito
Environments
- Dev, Test, Staging, Production
Cloud/Platform
- Project deployed in AWS or On-premises? CI/CD pipelines?
Architecture
- Draw a chart.
- Consists of: API Gateway, Service A/B/C, Messaging among services, Database
One Specific Functionality
- As detailed as possible. One or two APIs in detail(method, uri, payload). Service layers, which services are called? how the services communicates(REST, Messaging), where the data is stored(SQL Database, NoSQL, S3 bucket). Chanllenges.

Project 1: eBay - Data Analytics Dashboard
#

Company Info.
- eBay is an e-commerce company, that connects buyers and sellers around the world.
Project Name.
- Why the project exists? What’s the main goal?
  - The project is used to provide comprehensive insights and analytics to various departments within eBay, such as sales, marketing, product development, and customer support.
  - The dashboard will aggregate data from different sources, process it in real-time, and present it through interactive and customizable visualizations.
Users.
- The project is used by whom? How many users approximately?
  - This project is only used by internal users.
  - There is about 3,000 users are allowed to access the dashboard with different access level.
What’s the team structure.
- Agile Team (Scrum Master, Product Owner, Manager, Team Lead, Developers, QA, BA, DBA, DevOps)
  - 1 Product Manager + Scrum Master
  - 1 BA
  - 1 Project Manger + BE TL
  - BE 1 TL + 7 Dev
  - FE 1 TL + 5 Dev
  - QA 1 TL + 4 QA
  - DBA 2 DBA
  - DevOps 2 DevOps

What’s agile scrum flow?

Daily meetings, Jira, Planning meeting, demo, review, retrospective

The PM/SM is responsible for creating and maintaining the Product Backlog, a prioritized list of features, enhancements, and bug fixes required for the product.
One single Scrum Spring consists:

Product Backlog
     ↓
Sprint Planning
     ↓
Sprint Backlog
     ↓
   Sprint Execution (2-4 weeks)
   ↓                 ↓                 ↓
Daily Scrum      Development       Task Updates
   ↓                 ↓                 ↓
   Sprint Review (end of Sprint)
     ↓
Product Increment
     ↓
Sprint Retrospective
     ↓
Continuous Improvement & Next Sprint Planning

Your Main responsibilities.
- Design, Implement, Test XXX functions, Backend, DB, Frontend?
  - Work on tasks
  - Design the best solution of the task
  - Fix program issues
  - Conduct unit tests
  - Collaborate within the team
  - Work with external team
  - For example, I am responsible for designing and implementing the real-time data processing pipeline and integrating it with the frontend dashboard.

High-level System Structure

TechStack
- Java Version: Java 11
- Spring Boot: Version 2.5
- Databases: PostgreSQL for transactional data, MongoDB for NoSQL needs
- AWS (Cloud): EC2, RDS, S3, MSK (Managed Streaming for Apache Kafka), ElastiCache (Redis)
- Frontend Framework: Angular 11
- Testing Frameworks: JUnit 5, Mockito
Environments
- Development (Dev): Where initial development and testing occur.
- Testing (Test): Used by QA for functional and integration testing.
- Staging: Pre-production environment where final testing is conducted to mimic the production setup.
- Production: Live environment where the application is used by internal users.
Cloud/Platform
- Project deployed in AWS or On-premises? CI/CD pipelines?
  - Deployment: The project is deployed on AWS.
  - CI/CD Pipelines: Jenkins is used for continuous integration and continuous deployment, automating the build, test, and deployment processes across all environments.

Architecture

Draw a chart.
Consists of: API Gateway, Service A/B/C, Messaging among services, Database

+-------------------+       +-------------------+       +-------------------+
|                   |       |                   |       |                   |
|     API Gateway   | <---> |  Authentication   | <---> |  User Service     |
|                   |       |  Service (Spring  |       |  (Spring Boot)    |
|                   |       |  Boot + Spring    |       |                   |
+-------------------+       |  Security)        |       +-------------------+
         |                   +-------------------+              |
         |                                                    / \
         |                                                   /   \
         |                                                  /     \
+-------------------+       +-------------------+       +-------------------+
|                   |       |                   |       |                   |
|   Activity        | <---> |  Messaging        | <---> |  Data Processing  |
|   Service         |       |  Service          |       |  Service          |
|   (Spring Boot)   |       |  (Kafka)          |       |  (Spring Boot)    |
|                   |       |                   |       |                   |
+-------------------+       +-------------------+       +-------------------+
         |                                                    |
         |                                                    |
         v                                                    v
+-------------------+       +-------------------+       +-------------------+
|                   |       |                   |       |                   |
|  PostgreSQL       |       |  Redis (Elasti-   |       |  MongoDB          |
|  (RDS)            |       |  Cache)           |       |                   |
|                   |       |                   |       |                   |
+-------------------+       +-------------------+       +-------------------+
         |
         |
         v
+-------------------+
|                   |
|  S3 (Data Storage)|
|                   |
+-------------------+

One Specific Functionality
- As detailed as possible. One or two APIs in detail(method, uri, payload). Service layers, which services are called? how the services communicates(REST, Messaging), where the data is stored(SQL Database, NoSQL, S3 bucket). Chanllenges.

One Specific Functionality.
- Functionality: Real-Time User Activity Logging and Analysis
- Detailed Breakdown:
  1. API Endpoint: Log User Activity
    - Method: POST
    - URI: /api/v1/activity/log
    - Payload:
    { "userId": "12345", "activityType": "SEARCH", "timestamp": "2024-06-21T10:15:30Z", "details": { "query": "laptop", "resultsCount": 150 } }
  2. Service Layers:
    - API Gateway: Receives the API request and forwards it to the Authentication Service.
    - Authentication Service: Verifies the user’s identity using JWT tokens.
    - Activity Service: Handles the logging of user activity.
      - REST Communication: The API Gateway communicates with the Activity Service via REST.
  3. Internal Communication:
    - Activity Service: Receives the payload and sends it to the Messaging Service (Kafka) for real-time processing.
    - Messaging Service: Publishes the message to the relevant Kafka topic.
    - Data Processing Service: Subscribes to the Kafka topic, processes the message, and stores the processed data.
      - Storage:
        
        Transactional Data: Stored in PostgreSQL (RDS) for quick access and querying.
        
        Logs and Historical Data: Stored in MongoDB for flexible querying and analysis.
        
        Raw Data: Archived in S3 for long-term storage and potential future analysis.
  4. Challenge and Solutions:
    - Real-Time Data Processing: Ensuring low latency in processing high volumes of data. Solved by using Kafka for efficient message streaming and processing.
    - Data Consistency: Maintaining consistency between different databases (PostgreSQL and MongoDB). Used transaction management in Spring and eventual consistency principles.
    - Scalability: Handling increased load as user activity grows. Utilized AWS auto-scaling features for EC2 instances and optimized database queries.
    - Security: Ensuring data security during transit and storage. Implemented encryption (SSL/TLS) and AWS KMS for data at rest.

Project 2: Lewis Energy Group - Safety Incidents Management
#

Company Info.
- Lewis Energy is a natural gas drilling company.
Project Name.
- Why the project exists? What’s the main goal?
Users.
- The project is used by whom? How many users approximately?
What’s the team structure.
- Agile Team (Scrum Master, Product Owner, Manager, Team Lead, Developers, QA, BA, DBA, DevOps)
  - 1 Product Manager + Scrum Master
  - 1 BA
  - 1 Project Manger + BE TL
  - BE 1 TL + 5 Dev
  - FE 1 TL + 2 Dev
  - QA 1 TL + 1 QA
  - DBA 2 DBA
  - DevOps 1 DevOps

What’s agile scrum flow?

Daily meetings, Jira, Planning meeting, demo, review, retrospective

The PM/SM is responsible for creating and maintaining the Product Backlog, a prioritized list of features, enhancements, and bug fixes required for the product.

Product Backlog
     ↓
Sprint Planning
     ↓
Sprint Backlog
     ↓
   Sprint Execution (2-4 weeks)
   ↓                 ↓                 ↓
Daily Scrum      Development       Task Updates
   ↓                 ↓                 ↓
   Sprint Review (end of Sprint)
     ↓
Product Increment
     ↓
Sprint Retrospective
     ↓
Continuous Improvement & Next Sprint Planning

Your Main responsibilities.
- Design, Implement, Test XXX functions, Backend, DB, Frontend?
  - I was in BE team.
  - Write clean, maintainable, and efficient code using Spring Boot, Hibernate, and other back-end technologies.
High-level System Structure
1. TechStack
  - Java version, SpringBoot, REST, What kind of DB, AWS(Cloud), React/Angular, Junit, Mockito
2. Environments
  - Dev, Test, Staging, Production
3. Cloud/Platform
  - Project deployed in AWS or On-premises? CI/CD pipelines?
4. Architecture
  - Draw a chart.
  - Consists of: API Gateway, Service A/B/C, Messaging among services, Database
5. One Specific Functionality
  - As detailed as possible. One or two APIs in detail(method, uri, payload). Service layers, which services are called? how the services communicates(REST, Messaging), where the data is stored(SQL Database, NoSQL, S3 bucket). Chanllenges.
One Specific Functionality.

Project 3: Citi Bank - Tele Processing System
#

Company Info.
- It’s a banking company.
Project Name.
- Why the project exists? What’s the main goal?
Users.
- The project is used by whom? How many users approximately?
What’s the team structure.
- Agile Team (Scrum Master, Product Owner, Manager, Team Lead, Developers, QA, BA, DBA, DevOps)
  - 1 Product Manager + Scrum Master
  - 1 BA
  - 1 Project Manger + BE TL
  - BE 1 TL + 5 Dev
  - FE 1 TL + 2 Dev
  - QA 1 TL + 1 QA
  - DBA 2 DBA
  - DevOps 1 DevOps

What’s agile scrum flow?

Daily meetings, Jira, Planning meeting, demo, review, retrospective

The PM/SM is responsible for creating and maintaining the Product Backlog, a prioritized list of features, enhancements, and bug fixes required for the product.

Product Backlog
     ↓
Sprint Planning
     ↓
Sprint Backlog
     ↓
   Sprint Execution (2-4 weeks)
   ↓                 ↓                 ↓
Daily Scrum      Development       Task Updates
   ↓                 ↓                 ↓
   Sprint Review (end of Sprint)
     ↓
Product Increment
     ↓
Sprint Retrospective
     ↓
Continuous Improvement & Next Sprint Planning

Your Main responsibilities.
- Design, Implement, Test XXX functions, Backend, DB, Frontend?
  - I was in BE team.
  - Write clean, maintainable, and efficient code using Spring Boot, Hibernate, and other back-end technologies.
High-level System Structure
1. TechStack
  - Java version, SpringBoot, REST, What kind of DB, AWS(Cloud), React/Angular, Junit, Mockito
2. Environments
  - Dev, Test, Staging, Production
3. Cloud/Platform
  - Project deployed in AWS or On-premises? CI/CD pipelines?
4. Architecture
  - Draw a chart.
  - Consists of: API Gateway, Service A/B/C, Messaging among services, Database
5. One Specific Functionality
  - As detailed as possible. One or two APIs in detail(method, uri, payload). Service layers, which services are called? how the services communicates(REST, Messaging), where the data is stored(SQL Database, NoSQL, S3 bucket). Chanllenges.
One Specific Functionality.

Sure! Here's a plain English explanation of the project description:
The Tele Processing System is a tool used by Citi Private Banking to help clients move their money. It allows clients to transfer money from their Citi Private Banking accounts to other accounts outside Citi, as well as between their own accounts within Citi Private Banking.
To make these transfers happen, the Tele Processing System works with several other systems, including:

Flex Cube: A core banking system.
CAS: Likely a system for client account services.
CitiFT: Possibly a funds transfer system.
CitiTracs: Likely a transaction tracking system.
CitiSwitch: Possibly a payment processing system.
SEI: Could be a system for investment management.
Project One: Likely an internal project or system.
Document management system: Used for handling and storing documents related to the transfers.
In short, the Tele Processing System connects with various other systems to ensure that money transfers are done smoothly and efficiently for Citi Private Banking clients.

Project 4: Beijing Jishuitan Hospital - Drug Data System
#

Company Info.
- It’s a public hospital in Beijing.
Project Name.
- Why the project exists? What’s the main goal?
  - The hospital was planning to modernize and upgrade the current drug data system.
  - The hospital used to have separate data system for both chinese pharmacy and western pharmacy.
  - The goal of this project is to build a brand new drug data system that integrate both chinese pharmacy and western pharmacy. And do the data migration from the old system to the new system.
Users.
- The project is used by whom? How many users approximately?
  - The project is used by both internal user and external user.
  - There are about more than 2,000 internal users, including doctors and nurses.
  - For the external users, there are about 80,000 patients per year.
What’s the team structure.
- Agile Team (Scrum Master, Product Owner, Manager, Team Lead, Developers, QA, BA, DBA, DevOps)
  - 1 Product Manager + Scrum Master
  - 1 BA
  - 1 Project Manger + BE TL
  - BE 1 TL + 5 Dev
  - FE 1 TL + 2 Dev
  - QA 1 TL + 1 QA
  - DBA 2 DBA
  - DevOps 1 DevOps

What’s agile scrum flow?

Daily meetings, Jira, Planning meeting, demo, review, retrospective

The PM/SM is responsible for creating and maintaining the Product Backlog, a prioritized list of features, enhancements, and bug fixes required for the product.

Product Backlog
     ↓
Sprint Planning
     ↓
Sprint Backlog
     ↓
   Sprint Execution (2-4 weeks)
   ↓                 ↓                 ↓
Daily Scrum      Development       Task Updates
   ↓                 ↓                 ↓
   Sprint Review (end of Sprint)
     ↓
Product Increment
     ↓
Sprint Retrospective
     ↓
Continuous Improvement & Next Sprint Planning

Your Main responsibilities.
- Design, Implement, Test XXX functions, Backend, DB, Frontend?
  - I was in BE team.
  - Write clean, maintainable, and efficient code using Spring Boot, Hibernate, and other back-end technologies.
High-level System Structure
1. TechStack
  - Java version, SpringBoot, REST, What kind of DB, AWS(Cloud), React/Angular, Junit, Mockito
2. Environments
  - Dev, Test, Staging, Production
3. Cloud/Platform
  - Project deployed in AWS or On-premises? CI/CD pipelines?
4. Architecture
  - Draw a chart.
  - Consists of: API Gateway, Service A/B/C, Messaging among services, Database
5. One Specific Functionality
  - As detailed as possible. One or two APIs in detail(method, uri, payload). Service layers, which services are called? how the services communicates(REST, Messaging), where the data is stored(SQL Database, NoSQL, S3 bucket). Chanllenges.
One Specific Functionality.

Interview Questions

Thu, 20 Jun 2024 22:49:47 -0400

Questions
#

Important
#

Introduce your self and the previous project in 2 to 3 minutes.
- Hi, thanks for having me today. My name is Austin Wang. I a professional Java developer with over 6 years experience.
- Within my past working experience, all the projects I have are Web-Application.
- So I am very proficient in back-end programming with Java and Spring Framework.
- and also many other web technologies.
- like database including the relational and non-relational ones.
- the messaging queue systems like Kafka
- the ORM(Object-relational mapping) frameworks including hibernate and Spring Data JPA, and so on.
- I also have experience in developing front-end using Angular.
- I am an AWS-certified solution architect with real hands-on experience.
- The most recent project I am currently working on is called Data Analytics Dashboard System at Shopify company. This project is only designed for internal users only. They will use this system provide analytics and some comprehensive insights to various departments like sales department, customer support department, and so on. The Data Analytics Dashboard System also supports Role based access control for different users.
- With those knowledge and experience I can work on any complex and sophisticated project for the company.
- Thank you!
Describe a specific function/feature you did in last project. As detailed as possible.

Projects V3

Wed, 19 Jun 2024 22:42:17 -0400

Descriptions (3-5 sentences, 30 sec, industry, admin/internal/external/hybrid)
#

It’s an E-commerce web app where users can browse products, add items to a cart, place orders, and make payments.
It supports Role Based Access Control(RBAC) for both internal users to update products price or quantity and external users to browse, search and buy products.

Data Flow (frontend data, what kind of payload, what kind of format, design data flow: FE->BE->DB, then we have architecture, then in the middle: add buffering or caching, just add different tools to handle different problem, i.e. failure tolerance, scalability, ….)
#

Projects V2

Tue, 18 Jun 2024 22:42:17 -0400

Descriptions (3-5 sentences, 30 sec, industry, admin/internal/external/hybrid)
#

It’s an E-commerce web app where users can browse products, add items to a cart, place orders, and make payments.
It supports Role Based Access Control(RBAC) for both internal users to update products price or quantity and external users to browse, search and buy products.

Data Flow (frontend data, what kind of payload, what kind of format, design data flow: FE->BE->DB, then we have architecture, then in the middle: add buffering or caching, just add different tools to handle different problem, i.e. failure tolerance, scalability, ….)
#

Spring Data Jpa

Sat, 01 Jun 2024 21:42:22 -0400

Setup
#

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

        <!-- for mongodb -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>

        <!-- for postgresql -->
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <version>${postgresql.version}</version>
        </dependency>

        <!-- for mysql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.32</version>
        </dependency>

Entities
#

@Entity
@Table(name="course")
public class Course {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  private String name;

  @Column
  private Integer credit;

  @OneToOne
  @JoinColumn(name = "teacher_id")
  private Teacher teacher;

  @OneToMany(mappedBy = "course")
  private List<Enrollment> enrollmentList;

  // setter and getter ...
}

@Entity
@Table(name = "enrollment")
public class Enrollment {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  @ManyToOne
  private Course course;

  @ManyToOne
  private Student student;

  private Integer score;

  // setter and getter ...
}

@Entity
@Table(name = "student")
public class Student {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  private String name;

  private LocalDate dob;

  @OneToMany(mappedBy = "student")
  List<Enrollment> enrollmentList;

  // setter and getter ...
}

mongodb
#

@Document("enrollment_history")
public class History {
  @Id
  private String id;

  private String action;
  private String studentName;
  private String courseName;

  // setter and getter ...
}

MVC
#

package structures:
- configuration
- controller
- data
- entity
  - mongodb
    - History.java
  - Course
  - Enrollment
  - Student
  - Teacher
- repository
  - mongodb
    - HistoryRepository.java
  - EnrollmentRepository.java
  - StudentRepository.java
  - TeacherRepository.java
- service
  - EnrollmentService.java
  - EnrollmentServiceImpl.java
  - StudentService.java
  - StudentServiceImpl.java
  - TeacherService.java
  - TeacherServiceImpl.java
  - UserService.java
  - UserServiceImpl.java
  - UserServiceImpl2.java
- util
- vo
- SpringBootDemoApplication.java

Dao layer
#

// package ...

// import ...Enrollment;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface EnrollmentRepository extends JpaRepository<Enrollment, Long> {
}

// package ...

// import ...Student;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface StudentRepository extends JpaRepository<Student, Long> {
}

// package ...

// import ...Teacher;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface TeacherRepository extends JpaRepository<Teacher, Long> {
  // select * from teachers where age < 40 and id > 1000;
  List<Teacher> findByAgeLessThan(int age);
  List<Teacher> findByAge(int age);

  // @Query(value = "select t from Teacher t where t.age < ? and t.id > ?", nativeQuery = true) // native sql query
  @Query(value = "select t from Teacher t where t.age < :age and t.id > :id") // jpql
  List<Teacher> a(int age, long id);
}

mongodb
#


public interface HistoryRepository extends MongoRepository<History, String> {
  List<History> findByAction(String action);
  List<History> findByCourseName(String courseName);
}

Test Repositories
#

Hibernate

Sat, 01 Jun 2024 15:07:08 -0400

Concepts
#

JDBC -> JPA -> Hibernate -> Spring Data JPA / Spring Data Mongodb / Spring Data Elastic Search
Session Factory grabs the configFile: username + password, then creates sessions
Hibernate use reflection API to auto generate SQL statements
Hibernate allows us to write:
1. HQL(Hibernate Query Language), just in case the APIs are not flexible enough to catering some situations.
2. Native SQL. cons: with dialect language(mysql, postgres, oracle)
Cache strategies in Hibernate:

JDBC

Fri, 31 May 2024 22:26:39 -0400

github

Setup
#

        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <version>${postgresql.version}</version>
        </dependency>

package com.yixianwang.todolistbackend;

public class JdbcConfig {
    private static final String url = "jdbc:postgresql://localhost:5432/test";
    private static final String user = "postgres";
    private static final String password = "1234";

    public JdbcConfig() {
    }

    public static String getUrl() { return url; }
    public static String getUser() { return user; }
    public static String getPassword() { return password; }
}

Query
#

use ResultSet rs = stmt.executeQuery(strSelect);

package com.yixianwang.todolistbackend;

import java.sql.*;

public class JdbcSelectTest {
    public static void main(String[] args) {
        try (
            Connection conn = DriverManager.getConnection(
                JdbcConfig.getUrl(),
                JdbcConfig.getUser(),
                JdbcConfig.getPassword()
            );
            Statement stmt = conn.createStatement();
        ) {
            String strSelect = "select * from cars";
            ResultSet rs = stmt.executeQuery(strSelect);

            int rowCount = 0;
            while (rs.next()) {
                String brand = rs.getString("brand");
                String model = rs.getString("model");
                Integer year = rs.getInt("year");
                System.out.println(brand + " " + model + " " + year);
                ++rowCount;
            }
            System.out.println("Total number of rows:" + rowCount);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

Update
#

use int countUpdate = stmt.executeUpdate(strUpdate);

package com.yixianwang.todolistbackend;

import java.sql.*;

public class JdbcUpdateTest {
    public static void main(String[] args) {
        try (
                Connection conn = DriverManager.getConnection(
                        JdbcConfig.getUrl(),
                        JdbcConfig.getUser(),
                        JdbcConfig.getPassword()
                );
                Statement stmt = conn.createStatement();
        ) {
            String strUpdate = "update cars set year = 1234 where brand = 'Honda'";
            int countUpdate = stmt.executeUpdate(strUpdate);
            System.out.println(countUpdate + " recoreds are updated");

            String strSelect = "select * from cars";
            ResultSet rs = stmt.executeQuery(strSelect);

            int rowCount = 0;
            while (rs.next()) {
                String brand = rs.getString("brand");
                String model = rs.getString("model");
                Integer year = rs.getInt("year");
                System.out.println(brand + " " + model + " " + year);
                ++rowCount;
            }
            System.out.println("Total number of rows:" + rowCount);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

Insert and Delete
#

use int countDelete = stmt.executeUpdate(sqlDelete);
use int countInsert = stmt.executeUpdate(sqlInsert);

package com.yixianwang.todolistbackend;

import java.sql.*;

public class JdbcInsertAndDeleteTest {
    public static void main(String[] args) {
        try (
                Connection conn = DriverManager.getConnection(
                        JdbcConfig.getUrl(),
                        JdbcConfig.getUser(),
                        JdbcConfig.getPassword()
                );
                Statement stmt = conn.createStatement();
        ) {
            System.out.println("-------------------delete------------------");
            String sqlDelete = "delete from cars where brand = 'Apple'";
            int countDelete = stmt.executeUpdate(sqlDelete);
            System.out.println(countDelete + " records are deleted");

            System.out.println("-------------------insert one record------------------");
            String sqlInsert = "insert into cars" + " values ('Banana', 'haha', 1)";
            int countInsert = stmt.executeUpdate(sqlInsert);
            System.out.println(countInsert + " records are inserted");

            System.out.println("-------------------insert multiple record------------------");
            String sqlMultiInsert = "insert into cars values " + "('Tomato', 'hoho', 2), " + "('Pineapple', 'hihi', 3)";
            int countMultiInsert = stmt.executeUpdate(sqlMultiInsert);
            System.out.println(countMultiInsert + " records are inserted");

            System.out.println("-------------------partial insert------------------");
            String sqlPartialInsert = "insert into cars (brand, model)" + "values ('Jeep', 'Wrangler')";
            int countPartialInsert = stmt.executeUpdate(sqlPartialInsert);
            System.out.println(countPartialInsert + " records are inserted");

            System.out.println("-------------------Print Final Table------------------");
            String sqlSelect = "select * from cars";
            ResultSet rs = stmt.executeQuery(sqlSelect);
            while (rs.next()) {
                String brand = rs.getString("brand");
                String model = rs.getString("model");
                Integer year = rs.getInt("year");
                System.out.println(brand + " " + model + " " + year);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Transaction
#

use conn.setAutoCommit(false);
use conn.commit();
use conn.rollback();

package com.yixianwang.todolistbackend;

import java.sql.*;

public class JdbcTransactionTest {
    public static void main(String[] args) {
        try (
                Connection conn = DriverManager.getConnection(
                        JdbcConfig.getUrl(),
                        JdbcConfig.getUser(),
                        JdbcConfig.getPassword()
                );
                Statement stmt = conn.createStatement();
        ) {
            conn.setAutoCommit(false);

            // before update
            System.out.println("before update:");
            String sqlSelect = "select * from cars";
            ResultSet rs = stmt.executeQuery(sqlSelect);
            while (rs.next()) {
                String brand = rs.getString("brand");
                String model = rs.getString("model");
                Integer year = rs.getInt("year");
                System.out.println(brand + " " + model + " " + year);
            }
            conn.commit();

            // update something
            stmt.executeUpdate("update cars set year = 2024 where brand = 'Honda'");
            stmt.executeUpdate("update cars set year = 2024 where brand = 'Ford'");
            conn.commit();

            // after update (commit)
            System.out.println();
            System.out.println("after update commit:");
            String sqlSelect2 = "select * from cars";
            ResultSet rs2 = stmt.executeQuery(sqlSelect2);
            while (rs2.next()) {
                String brand = rs2.getString("brand");
                String model = rs2.getString("model");
                Integer year = rs2.getInt("year");
                System.out.println(brand + " " + model + " " + year);
            }
            conn.commit();

            // update but rollback
            System.out.println();
            System.out.println("update but rollback");
            stmt.executeUpdate("update cars set year = 2011 where brand = 'Honda'");
            stmt.executeUpdate("update cars set year = 2011 where brand = 'Ford'");
            conn.rollback();

            // after update (rollback)
            System.out.println();
            System.out.println("after update rollback");
            String sqlSelect3 = "select * from cars";
            ResultSet rs3 = stmt.executeQuery(sqlSelect3);
            while (rs3.next()) {
                String brand = rs3.getString("brand");
                String model = rs3.getString("model");
                Integer year = rs3.getInt("year");
                System.out.println(brand + " " + model + " " + year);
            }
            conn.commit();

        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

Roll Back in Catch
#

use conn.rollback(); within catch block

Batch Processing with Prepared Statement
#

purpose: to decrease the number of IO
use prepared statement

package com.yixianwang.todolistbackend;

import java.sql.*;

public class JdbcBatchProcessingPreparedStatTest {
    public static void main(String[] args) {
        try (
                Connection conn = DriverManager.getConnection(
                        JdbcConfig.getUrl(),
                        JdbcConfig.getUser(),
                        JdbcConfig.getPassword()
                );
                PreparedStatement pstmt = conn.prepareStatement(
                        "insert into cars values (?, ?, ?)"
                );
        ) {
            conn.setAutoCommit(false);
            pstmt.setString(1, "Apple");
            pstmt.setString(2, "Z1");
            pstmt.setInt(3, 2025);
            pstmt.addBatch();

            pstmt.setString(1, "Huawei");
            pstmt.setString(2, "Q1");
            pstmt.addBatch();

            int[] result = pstmt.executeBatch();
            conn.commit();
        } catch (SQLException e) {
        }
    }
}

Prepared Statement
#

purpose: to solve sql injection

package com.yixianwang.todolistbackend;

import java.sql.*;

public class JdbcPreparedStatementTest {
    public static void main(String[] args) {
        try (
                Connection conn = DriverManager.getConnection(
                        JdbcConfig.getUrl(),
                        JdbcConfig.getUser(),
                        JdbcConfig.getPassword()
                );
                PreparedStatement pstmt = conn.prepareStatement(
                        "insert into cars values (?, ?, ?)"
                );
                PreparedStatement pstmtSelect = conn.prepareStatement("select * from cars");
        ) {
            pstmt.setString(2, "RX350");
            pstmt.setInt(3, 2020);
            int rowsInserted = pstmt.executeUpdate();
            System.out.println(rowsInserted + " records inserted");

            // partial changes
            pstmt.setString(1, "Tesla");
            rowsInserted = pstmt.executeUpdate();
            System.out.println(rowsInserted + " records inserted");

            ResultSet rs = pstmtSelect.executeQuery();
            while (rs.next()) {
                String brand = rs.getString("brand");
                String model = rs.getString("model");
                Integer year = rs.getInt("year");
                System.out.println(brand + " " + model + " " + year);
            }

        } catch (SQLException e) {
        }
    }
}

Go Advanced

Fri, 24 May 2024 00:20:16 -0400

Setting up
#

file structure
#

some_folder/module_name/package_name/go_file.go

new project == new module
#

name module with github repository is very common

go mod init github.com/yixianwang/module_name

go run
#

equals to go build and then run executable

Data Types
#

const myConst
var myVar

bool
float32 float64
int int16 int32 int64
rune
string
unit uint8 uint16 uint32 uint64

built-in package import "unicode/utf8" then use utf8.RuneCountInString("汉")

Go Syntax

Wed, 22 May 2024 21:11:38 -0400

1. workspace
#

go env GOPATH

1.1 file structures
#

/Users/username/go/src/project1
/Users/username/go/src/project2

2. package main
#

every project at least if we want to be executed it needs to have a package called package main

3. import
#

this is where we can import different packages

no comma

Projects

Mon, 20 May 2024 22:30:29 -0400

general concepts
#

Role Based Access Control(RBAC):
- Once we login an account, we have different roles, different roles will see different contents.
- whether we are admin or external user, internal user.
- if we are external user, we have different vip levels or different discount, and so on.

core
#

describe it within a minute(3-5 sentences, 30 secs)

SOLID

Mon, 29 Apr 2024 20:09:27 -0400

S: Single-responsibility Principle
O: Open-closed Principle
L: Liskov Substitution Principle
I: Interface Segregation Principle
D: Dependency Inversion Principle
Reference

S - Single-responsibility Principle
#

DEFINE: The interface responsibility should be single and not take on too many responsibilities.
Applies to interfaces, classes, and methods.
The focus of the single responsibility principle lies in the division of responsibilities, which is often not static and needs to be determined based on the actual situation.
PROS: It can reduce class complexity, clarify responsibilities between classes, improve code readability, and make it easier to maintain.
CONS: The knowledge and skills required of technicians are high, and sometimes it is difficult to distinguish between responsibilities.

O - Open-closed Principle
#

DEFINE: when someone else wants to modify the software function, he cannot modify our original code and can only add new code to achieve the purpose of modifying the software function.
EXAMPLE: we should can only create a new class to implement interface.

L - Liskov Substitution Principle
#

DEFINE: For users, where the parent class can be used, its subclasses can also be used, and the expected results are consistent.
It not only refers to the syntax level consistency, but also includes the implementation consistency.

I - Interface Segregation Principle
#

DEFINE: Don’t throw a large and comprehensive interface to users, but separate the interface that each user cares about.

D - Dependency Inversion Principle
#

It is recommended that users rely on an abstract class or interface instead of relying on a implementation.

SOLID - GPT
#

The SOLID principles are a set of five design principles intended to make software designs more understandable, flexible, and maintainable. They were introduced by Robert C. Martin (also known as Uncle Bob). Each letter in the acronym SOLID stands for one of the principles:

AWS

Mon, 29 Apr 2024 15:12:10 -0400

SAA-02 Reference

Global Services
#

Identity and Access Management (IAM)
Route 53 (DNS service)
CloudFront (Content Delivery Network)
WAF (Web Application Firewall)

Region-scoped
#

Amazon EC2 (Infrastructure as a Service)
- Renting virtual machines (EC2)
- Storing data on virtual drives (EBS)
- Elastic File System (EFS)
- Distributing load across machines (ELB)
- Scaling the services using an auto-scaling group (ASG)
Elastic Beanstalk (Platform as a Service)
Lambda (Function as a Service)
Rekognition (Software as a Service)

Concepts
#

RDS Multi-AZ = Synchronous = High Availability
Read Replica = Asynchronous = Disaster Recovery (DR)

IAM
#

which aws
aws --version

aws configure

aws iam list-users

Section 7: EC2 Instance Storage
#

EBS
#

Cheat Sheet

Sat, 20 Apr 2024 18:58:08 -0400

QuickNotes
#

singleton vs immutable class

functional interface with static

Core Java interview questions
#

Java is passed by Value or Reference?
#

In Java, there are two kinds of data type, Primitive data types and Non-primitive data types.
For primitive types, they are built-in data types in Java including int/short/long/float/double/char/byte/boolean. They are all passed by value.
For non-primitive types, they are also passed by value, the value here is actually the memory address of the object. e.g. annotation, class, interface, enum, array.
In conclusion all data types in Java are passed by value.

static keyword(within 5 sentences)
#

we have four places to put static keyword on.(class, method, variable, block)
For having static keyword on method, variable scope is to ensure that they can share just by class template.
what SCOPES we can access static elements.
- we cannot override static method
- static class cannot called by non-static method

static block
#

static block is a set of instructions that is run only once when a class is loaded into memory.
- We use a static block to initialize static variables. Although we can initialize static variables directly during declaration, there are situations when we need to do multiline processing. In such cases, static blocks come in handy.
- If static variables require additional, multi-statement logic during initialization, we can use a static block.
- Below are a few reasons for for using static blocks:
  - if the initialization of static variables needs some additional logic apart from the assignment
  - if the initialization of static variables is error-prone and needs exception handling

static class
#

In general, the nested class architecture is divided into two types:

A Code

Tue, 16 Apr 2024 01:58:31 -0400

Top K(quick select)
#

Leetcode 215 Kth largest

int partition(vector<int>& nums, int start, int end) {
  int pivot = nums[start];
  int i = start, j = end;
  while (i < j) {
    while (i < j && nums[j] >= pivot) --j;
    nums[i] = nums[j];
    while (i < j && nums[i] <= pivot) ++i;
    nums[j] = nums[i];
  }
  nums[i] = pivot;
  return i;
}

void TopKSplit(vector<int>& nums, int k, int left, int right) {
  int idx = partition(nums, left, right);
  if (idx == k) return;
  else if (idx < k) TopKSplit(nums, k, idx + 1, right);
  else TopKSplit(nums, k, left, idx - 1);
}

int findKthLargest(vector<int>& nums, int k) {
  TopKSplit(nums, nums.size() - k, 0, nums.size() - 1);
  return nums[nums.size() - k];
}

Coding: 实现 ArrayList 的 get 方法和 add 方法(by index)
#

Reference

import java.io.Serializable;
import java.util.Arrays;
import java.util.RandomAccess;

public class SimpleArrayList<E> implements RandomAccess, Cloneable, Serializable {
    private final static int DEFAULT_CAPACITY = 10;
    private int size = 0;

    private Object[] elementData;

    public SimpleArrayList() {
        this(DEFAULT_CAPACITY);
    }

    public SimpleArrayList(int size) {
        if (size < 0) {
            throw new IllegalArgumentException("Size should be positive integer!" + size);
        } else {
            elementData = new Object[size];
        }
    }

    public void add(E e) {
        isCapacityEnough(size + 1);
        elementData[size++] = e;
    }

    public void add(int index, E e) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("Please give a legal index!");
        }
        isCapacityEnough(size + 1);
        System.arraycopy(elementData, index, elementData, index + 1, size - index);
        elementData[index] = e;
        size++;
    }

    private void isCapacityEnough(int size) {
        if (size > DEFAULT_CAPACITY) {
            explicitCapacity(size);
        }
        if (size < 0) {
            throw new OutOfMemoryError();
        }
    }

    private final static int MAX_ARRAY_LENGTH = Integer.MAX_VALUE - 8;

    private void explicitCapacity(int capacity) {
        int newLength = elementData.length * 2;
        if (newLength - capacity < 0) {
            newLength = capacity;
        }
        if (newLength > (MAX_ARRAY_LENGTH)) {
            newLength = (capacity > MAX_ARRAY_LENGTH ? Integer.MAX_VALUE : MAX_ARRAY_LENGTH);
        }
        elementData = Arrays.copyOf(elementData, newLength);
    }

    public E get(int index) {
        if (index >= size || index < 0) {
            throw new IndexOutOfBoundsException("Please give a legal index");
        }
        return (E) elementData[index];
    }
}

Character count
#

String input = "ABCDCCCDAA";
HashMap<Character, Integer> hm = new HashMap<>();
for (Character c : input.toCharArray()) {
    hm.put(c, hm.getOrDefault(c, 0) + 1);
}

find the largest and the second largest
#

int first = 0x3f3f3f3f, second = first;
int idx = 0;
while (idx < v.length) {
    if (v[idx] > first) {
      second = first;
      first = v[idx];
    } else if (v[idx] > second) second = v[idx];
    ++idx;
}

find unique char in string
#

int[] cnt = new int[26];
Arrays.fill(cnt, 0);
for (char c : s.toCharArray()) {
    ++cnt[c - 'a'];
}

find unique int
#

HashMap<Integer, Integer> hm = new HashMap<>();
for (int vi : v) {
    hm.put(vi, hm.getOrDefault(vi, 0) + 1);
}

subarray sum equals to K
#

// Approach 1
if (nums == null || nums.length == 0) return 0;
int ans = 0;
for (int i = 0; i < nums.length; ++i) {
    int sum = 0;
    for (int j = i; j < nums.length; ++j) {
        sum += nums[j];
        if (k == sum) ++ans;
    }
}
return ans;

// Approach 2
int subarraySum(int[] nums, int k) {
    if (nums == null || nums.length == 0) return 0;
    int sum = 0;
    HashMap<Integer, Integer> hm = new HashMap<>();
    int ans = 0;
    hm.put(0, 1);
    for (int i = 0; i < nums.length; ++i) {
        sum += nums[i];
        if (hm.containsKey(sum - k)) {
            ans += hm.get(sum - k);
        }
        hm.put(sum, hm.getOrDefault(sum, 0) + 1);
    }
    return ans;
}

max consecutive ones
#

int findMaxConsecutiveOnes(int[] nums) {
    int cnt = 0, ans = 0;
    for (int n : nums) {
        if (n == 1) ++cnt;
        else {
            ans = Math.max(ans, cnt);
            cnt = 0;
        }
    }
    ans = Math.max(ans, cnt);
    return ans;
}

K largest element in an Array
#

int partition(vector<int>& nums, int start, int end) {
  int pivot = nums[start];
  int i = start, j = end;
  while (i < j) {
    while (i < j && nums[j] >= pivot) --j;
    nums[i] = nums[j];
    while (i < j && nums[i] <= pivot) ++i;
    nums[j] = nums[i];
  }
  nums[i] = pivot;
  return i;
}

void TopKSplit(vector<int>& nums, int k, int left, int right) {
  int idx = partition(nums, left, right);
  if (idx == k) return;
  else if (idx < k) TopKSplit(nums, k, idx + 1, right);
  else TopKSplit(nums, k, left, idx - 1);
}

int findKthLargest(vector<int>& nums, int k) {
  TopKSplit(nums, nums.size() - k, 0, nums.size() - 1);
  return nums[nums.size() - k];
}

String compression
#

int compress(char[] chars) {
    if (chars.length == 0) return 0;
    int left = 0, right = 0;
    while (right < chars.length) {
        int len = 1;
        while (right + len < chars.length && chars[right] == chars[right + len]) {
            ++len;
        }
        chars[left++] = chars[right];
        if (len > 1) {
            String len_s = Integer.toString(len);
            for (Character c : len_s.toCharArray()) {
                chars[left++] = c;
            }
        }
        right += len;
    }
    return left;
}

Group Anagrams
#

public List<List<String>> groupAnagrams(String[] strs) {
    if (strs.length == 0) return new ArrayList();
    Map<String, List> ans = new HashMap<String, List>();
    int[] count = new int[26];
    for (String s : strs) {
        Arrays.fill(count, 0);
        for (char c : s.toCharArray()) count[c - 'a']++;

        StringBuilder sb = new StringBuilder("");
        for (int i = 0; i < 26; i++) {
            sb.append('#');
            sb.append(count[i]);
        }
        String key = sb.toString();
        if (!ans.containsKey(key)) ans.put(key, new ArrayList());
        ans.get(key).add(s);
    }
    return new ArrayList(ans.values());
}

Fibonacci Number
#

// Creating a hash map with 0 -> 0 and 1 -> 1 pairs
private Map<Integer, Integer> cache = new HashMap<>(Map.of(0, 0, 1, 1));

public int fib(int N) {
    if (cache.containsKey(N)) {
        return cache.get(N);
    }
    cache.put(N, fib(N - 1) + fib(N - 2));
    return cache.get(N);
}

public int fib(int N) {
    if (N <= 1) {
        return N;
    }

    int current = 0;
    int prev1 = 1;
    int prev2 = 0;

    for (int i = 2; i <= N; i++) {
        current = prev1 + prev2;
        prev2 = prev1;
        prev1 = current;
    }
    return current;
}

Get second frequently string from list of string
#

ArrayList<String> input = new ArrayList<>();
input.add("apple");
input.add("apple");
input.add("banana");
input.add("orange");
input.add("banana");
input.add("apple");

HashMap<String, Integer> hm = new HashMap<>();
for (String s : input) {
    hm.put(s, hm.getOrDefault(s, 0) + 1);
}

hm.put("", 0);
String first = "";
String second = "";
for (String key : hm.keySet()) {
    Integer val = hm.get(key);
    if (hm.get(first) < val) {
        second = first;
        first = key;
    } else if (hm.get(second) < val) second = key;
}

Valid anagram
#

public boolean isAnagram(String s, String t) {
    if (s.length() != t.length()) {
        return false;
    }
    int[] counter = new int[26];
    for (int i = 0; i < s.length(); i++) {
        counter[s.charAt(i) - 'a']++;
        counter[t.charAt(i) - 'a']--;
    }
    for (int count : counter) {
        if (count != 0) {
            return false;
        }
    }
    return true;
}

input: 1,1,2,5,5,8,9 output: 1,2,,,5,,,8,9
#

int max_v = 0;
for (int vi : v) {
    if (vi > max_v) max_v = vi;
}
int[] ans = new int[max_v];
Arrays.fill(ans, -1);
for (int vi : v) {
    ans[vi - 1] = vi;
}

subsequence sum equals to K
#

void solution() {
    int[] input = {1,2,3,4,5,6,7};
    Arrays.sort(input);
    ArrayList<ArrayList<Integer>> combinations = new ArrayList<>();
    ArrayList<Integer> comb = new ArrayList<>();
    Helper(input, 0, combinations, comb, 0);
    System.out.println(combinations);
}

void Helper(int[] nums, int start, ArrayList<ArrayList<Integer>> combinations, ArrayList<Integer> comb, int sum) {
    if (sum == 6) {
        combinations.add(new ArrayList<>(comb));
    }
    for (int i = start; i < nums.length; i++) {
        comb.add(nums[i]);
        sum += nums[i];
        Helper(nums, i + 1, combinations, comb, sum);
        sum -= nums[i];
        comb.remove(comb.size() - 1);
    }
}

Java Last Minute

Thu, 11 Apr 2024 23:30:02 -0400

Basic data types
#

int <-> String
#

// first is "123"
// scond is "234"
String sumStr = String.valueOf(Long.parseLong(first) + Long.parseLong(second));

1D Array
#

int[] r = new int[26];
// r.length;

String[] r = {"c1", "c2", "c3"};
Arrays.fill(r, 0);

2D Array
#

String[][] r = new String[3][3];

String[][] r = {{"a", "b"}, {"c", "d"}};
for (String[] row : r) {
    Arrays.fill(row, "apple"); // Fill each row with the string "apple"
}

Character
#

Character.isLetterOrDigit(s.charAt(i)) // isWhitespace, isLetter, isDigit
Character.toLowerCase(s.charAt(i)) != Character.toLowerCase(s.charAt(j))

String
#

String name = "Bro";
// name.length();

char[] ch = str.toCharArray();
return new String(ch) // convert char array back to String

substring(int beginIndex, int endIndex)

String r = name.trim();
String r = name.replace('o', 'a');  // Replace all 'a' to 'o'

boolean r = name.equals("Bro");
boolean r = name.equalsIgnoreCase("bro");
int r = str1.compareTo(str2) // lexicographically, > 0, < 0, == 0

char r = name.charAt(0);
int r = name.indexOf("B");
boolean r = name.startsWith("A");
boolean r = name.isEmpty();
String r = name.toUpperCase(); // toLowerCase

List<String> wordList = Arrays.asList(s.split("\\s+")); // split by multiple spaces
Collections.reverse(wordList);
String r = String.join(" ", wordList); // return a String

StringBuilder
#

StringBuilder sb = new StringBuilder();
// sb.length();

sb.append(str); // append the string to string builder
sb.insert(offset, str, start, end);
sb.delete(start, end);
sb.deleteCharAt(idx);
sb.setCharAt(idx, 'z');
sb.toString(); // convert string builder to string

ArrayList
#

ArrayList<String> r = new ArrayList<>();
// r.size();

r.add("add at the end");
r.add("add at idx 1", 1);
r.remove(2); // remove at index 2
r.clear();
r.set(0, "replace at index 0");
r.get(0);

// array -> list
List<Boolean> result = Arrays.asList(new Boolean[candies.length]); // fix-sized list
return Arrays.asList(array); // from Array to List

// list -> array
String[] array = new String[0];
array = list.toArray(array);

2D ArrayList
#

ArrayList<ArrayList<String>> r = new ArrayList();

Deque
#

// better performance. internal data structure is array, doesn't support null 
Deque<Integer> arrayDeque = new ArrayDeque<>();
// better flexibility. internal data structure is double linked list, support null 
Deque<Integer> linkedList = new LinkedList<>();
// dq.size();

// peekFirst() peekLast()
int pf = arrayDeque.peekFirst();
int pl = arrayDeque.peekLast();

// offerFirst() offerLast()
arrayDeque.offerFirst(20);
arrayDeque.offerLast(10);

// removeFirst() removeLast()
int dequeuedFromArrayDeque1 = arrayDeque.removeFirst();
int dequeuedFromArrayDeque2 = arrayDeque.removeLast();

// pollFirst() pollLast()
// Does not throw an exception if the deque is empty.
int dequeuedFromArrayDeque1 = arrayDeque.pollFirst();
int dequeuedFromArrayDeque2 = arrayDeque.pollLast();

HashSet
#

HashSet<String> hs = new HashSet<>();
// hs.size();

hs.add("Apple");
hs.remove("Apple");
hs.clear();
boolean containsApple = hs.contains("Apple");

Set<String> synchronizedSet = Collections.synchronizedSet(new HashSet<>());

HashMap
#

HashMap<String, String> hm = new HashMap<>();
// hm.size();

hm.put("USA", "DC"); // if key doesn't exist: add, otherwise update value
hm.putIfAbsent("USA", "Austin"); // if key exist, do nothing, otherwise add

hm.remove("USA");
hm.clear();

hm.replace("USA", "Miami"); // if key doesn't exist, do nothing

hm.getOrDefault("USA", "Dallas");
hm.get("USA");

hm.containsKey("USA");
hm.containsValue("DC");

for (String key : hm.keySet()) {
  String val = hm.get(key);
  ...
}

if (!ans.containsKey(key)) ans.put(key, new ArrayList());

return new ArrayList(ans.values()); // Map<String, List> -> List<List<String>>

return new ArrayList(); // for return empty (List<List<AnyType>>)

Map<Integer, String> synchronizedHashMap = Collections.synchronizedMap(new HashMap<>());

TreeSet
#

TreeSet<Student> ts = new TreeSet<>(
    (l, r) -> (l.age - r.age)
);

Comparator<Student> ageComparator = new Comparator<Student>() {
   @Override
   public int compare(Student s1, Student s2) {
       return Integer.compare(s1.getAge(), s2.getAge());
   }
};
TreeSet<Student> student = new TreeSet<>(ageComparator);

ts.add(new Student(1, "a")); // idempotent: if exist, do nothing
ts.remove(new Student(1, "a")); // idempotent
// to update: remove the old one, add the updated one
ts.contains(new Student(1, "a"); // safe

Student first = ts.first();
Student last = ts.last();
Student lower = ts.lower(new Student(3, "anything"));
Student higher = ts.higher(new Student(3, "anything"));
Student floor = ts.floor(new Student(3, "anything"));
Student ceiling = ts.ceiling(new Student(3, "anything));

TreeSet<Student> headSet = (TreeSet<Student>) people.headSet(new Student(21, "anything"));
TreeSet<Student> tailSet = (TreeSet<Student>) people.tailSet(new Student(21, "anything"));
TreeSet<Student> subSet = (TreeSet<Student>) people.subSet(new Student (3, "anything"), new Student (122, "anything"));

SortedSet<String> synchronizedTreeSet = Collections.synchronizedSortedSet(new TreeSet<>());

update element within TreeSet
#

public static void updatePersonAge(TreeSet<Person> people, String name, int newAge) {
  // Find the person with the given name
  Person personToUpdate = null;
  for (Person person : people) {
      if (person.getName().equals(name)) {
          personToUpdate = person;
          break;
      }
  }
  
  // If person is found, remove, update and reinsert
  if (personToUpdate != null) {
      people.remove(personToUpdate); // Remove the old person
      personToUpdate.setAge(newAge); // Update the age
      people.add(personToUpdate); // Add the updated person
  }
}

TreeMap
#

TreeMap<Integer, String> tm = new TreeMap<>();
// tm.size();

tm.put(3, "Three");
tm.remove(2);
tm.clear();
String v = tm.get(3);
boolean containsKey = tm.containsKey(1);
boolean containsValue = tm.containsValue("Four");

Integer firstKey = tm.firstKey();
Integer lastKey = tm.lastKey();

Integer lowerKey = treeMap.lowerKey(3); // Returns 2
Integer floorKey = treeMap.floorKey(3); // Returns 3
Integer higherKey = treeMap.higherKey(3); // Returns 4
Integer ceilingKey = treeMap.ceilingKey(3); // Returns 3

SortedMap<Integer, String> headMap = treeMap.headMap(3); // Elements < 3
SortedMap<Integer, String> tailMap = treeMap.tailMap(3); // Elements >= 3
SortedMap<Integer, String> subMap = treeMap.subMap(2, 4); // Elements >= 2 and < 4

SortedMap<Integer, String> synchronizedTreeMap = Collections.synchronizedSortedMap(new TreeMap<>());

HashTable
#

ConcurrentHashMap
#

ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>();
// map.size();

// basic operations
map.put(1, "One");
map.remove(2);
map.clear();
String value = map.get(1);
boolean containsKey = map.containsKey(3);
boolean containsValue = map.containsValue("Three");

// concurrent operations
map.putIfAbsent(4, "Four"); // Adds the value only if the key is not already present
map.remove(1, "One"); // Removes the entry only if the key is mapped to the specified value
map.replace(3, "Three", "ThreeReplaced"); // Replaces the value only if the key is mapped to the specified value
map.compute(3, (key, value) -> value + "Updated"); // Computes a new mapping for the specified key using the given remapping function
map.computeIfAbsent(5, key -> "Five"); // Computes a new value for the specified key if it is not already present
map.computeIfPresent(3, (key, value) -> value + "UpdatedAgain"); // Computes a new value for the specified key if it is already present

Iterating over ConcurrentHashMap
#

for (Integer key : map.keySet()) {
    System.out.println("Key: " + key + ", Value: " + map.get(key));
}

for (Map.Entry<Integer, String> entry : map.entrySet()) {
    System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
}

for (String value : map.values()) {
    System.out.println("Value: " + value);
}

PriorityQueue
#

PriorityQueue<Integer> pq = new PriorityQueue<>(
    (n1, n2) -> map.get(n1) - map.get(n2)
);
// pq.size();

pq.add(10);
int r = pq.poll();

int r = pq.peek();
boolean r = pq.isEmpty();

PriorityQueue + HashMap
#

// leetcode 347
class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        // 使用字典，统计每个元素出现的次数，元素为键，元素出现的次数为值
        Map<Integer, Integer> map = new HashMap();
        for(int num : nums){
            if (map.containsKey(num)) {
                map.put(num, map.get(num) + 1);
            } else {
                map.put(num, 1);
            }
        }

        // 遍历map，用最小堆保存频率最大的k个元素
        // PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>() {
        //     @Override
        //     public int compare(Integer a, Integer b) {
        //         return map.get(a) - map.get(b);
        //     }
        // });
        PriorityQueue<Integer> pq = new PriorityQueue<>(
            (n1, n2) -> map.get(n1) - map.get(n2)
        );

        for (Integer key : map.keySet()) {
            pq.add(key);
            if (pq.size() > k) {
                pq.poll();
            }
        }

        // 取出最小堆中的元素
        List<Integer> res = new ArrayList<>();
        while (!pq.isEmpty()) {
            res.add(pq.poll());
        }

        // List 变成 Array
        int[] arrayResult = new int[res.size()];
        for (int i = 0; i < res.size(); ++i) {
            arrayResult[i] = res.get(i);
        }
        return arrayResult;
    }
}

Queue + Pair
#

// leetcode 988
class Solution {
    public String smallestFromLeaf(TreeNode root) {
        String smallestString = "";
        Queue<Pair<TreeNode, String>> nodeQueue = new LinkedList<>();

        // Add root node to queue along with its value converted to a character
        nodeQueue.add(new Pair<>(root, String.valueOf((char)(root.val + 'a'))));

        // Perform BFS traversal until queue is empty
        while (!nodeQueue.isEmpty()) {

            // Pop the leftmost node and its corresponding string from queue
            Pair<TreeNode, String> pair = nodeQueue.poll();
            TreeNode node = pair.getKey();
            String currentString = pair.getValue();
    
            // If current node is a leaf node
            if (node.left == null && node.right == null) {
            
                // Update smallest_string if it's empty or current string is smaller
                if (smallestString.isEmpty()) {
                    smallestString = currentString;
                } else {
                    smallestString = currentString.compareTo(smallestString) < 0 ? currentString : smallestString;
                }
            }

            // If current node has a left child, append it to queue
            if (node.left != null) {
                nodeQueue.add(new Pair<>(node.left, (char)(node.left.val + 'a') + currentString));
            }

            // If current node has a right child, append it to queue
            if (node.right != null) {
                nodeQueue.add(new Pair<>(node.right, (char)(node.right.val + 'a') + currentString));
            }
        }

        return smallestString;
    }
}

Collections
#

sort
#

// List
Collections.sort(v, (l, r) -> l.name.compareTo(r.name));

// Array
Arrays.sort(v, (l, r) -> l.name.compareTo(r.name));

min
#

// List
Student my_min = Collections.min(vl, (l, r) -> l.age - r.age);

stream
#

// people is ArrayList
List<Person> hundredSorted = people.stream()
        .filter(person -> person.billions >= 100)
        .sorted(Comparator.comparing(person -> person.name))
        .collect(Collectors.toList());
hundredSorted.forEach(person -> System.out.println(person.name));

Functional Interface
#

Predicate: Represents a predicate (boolean-valued function) of one argument.

C++ Const

Sun, 31 Mar 2024 02:34:50 -0400

c++ const
#

link

  // value of x and y can be altered
  // x = 9; y = 'A';
  // value of i and j can be altered
  // i = &m; j = &n;
  // !!! value of *i and *j cannot be altered
  // *i = 6; *j = 7; // read-only variable is not assignable
  const int* i = &x;
  const char* j = &y;

  // value of x and y can be altered
  // x = 9; y = 'A';
  // !!! value of i and j cannot be altered
  // i = &m; j = &n; // variable 'i' and 'j' declared const here
  // value of *i and *j can be altered
  // *i = 6; *j = 'A';
  int* const i = &x;
  char* const j = &y;

  // value of x and y can be altered
  // x = 9; y = 'A';
  // !!! value of i and j cannot be altered
  // i = &m; j = &n;
  // !!! value of *i and *j cannot be altered
  // *i = 6; *j = 7;
  const int* const i = &x;
  const char* const j = &y;

The compile-time error that will appear as if const value is passed to any non-const argument of the function

C++ Comparator

Sun, 31 Mar 2024 02:31:00 -0400

Comparator - set
#

Leetcode 3102. Minimize Manhattan Distances

class Node {
 public:
  Node(int dist) : sum(dist) {}
  int first;
  int second;
  int sum;
};

class Comparator {
 public:
  // bool operator()(const int& a, const int& b) const {
  //   return a > b;
  // }
  // bool operator()(Node* const& left, Node* const& right) const { // works
  // bool operator()(Node* left, Node* right) const { // works
  bool operator()(const Node* left, const Node* right) const { // works
    if (left->sum == right->sum) {
      if (left->first == right->first) {
        return left->second < right->second;
      }
      return left->first < right->first;
    }
    return left->sum > right->sum;
  }
};

bool comp(Node* const& left, Node* const& right) {
  if (left->sum == right->sum) {
    if (left->first == right->first) {
      return left->second < right->second;
    }
    return left->first < right->first;
  }
  return left->sum > right->sum;
}

class Solution {
 public:
  int minimumDistance(vector<vector<int>>& nums) {
    if (nums.size() < 2) return -1;

    // set<Node*, decltype(&comp)> heap; // not work
    // set<Node*, decltype(&comp)> heap(&comp); // works
    // set<Node*, decltype(comp)*> heap(&comp); // works
    set<Node*, Comparator> heap; // works

    for (int i = 0; i < nums.size(); ++i) {
      for (int j = i + 1; j < nums.size(); ++j) {
        Node* node = new Node(Distance(nums[i][0], nums[j][0], nums[i][1], nums[j][1]));
        node->first = i;
        node->second = j;
        heap.insert(node);
      }
    }

    int min_val = INT_MAX;
    // iterate remove each
    for (int i = 0; i < nums.size(); ++i) {
      // remove i, then compete
      min_val = min(min_val, Find(heap, i));
    }
    return min_val == INT_MAX ? -1 : min_val;
  }

  int Find(set<Node*, Comparator>& heap, int idx) {
    for (auto it = heap.begin(); it != heap.end(); ++it) {
      if ((*it)->first != idx && (*it)->second != idx) {
        return (*it)->sum;
      }
    }
    return -1;
  }

  int Distance(int& x1, int& x2, int& y1, int& y2) {
    return abs(x1 - x2) + abs(y1 - y2);
  }
};

Comparator - priority_queue
#

Leetcode 23. Merge k Sorted Lists

// Comparison function for priority queue
struct CompareNodes {
  bool operator()(const ListNode* lhs, const ListNode* rhs) const {
    return lhs->val > rhs->val;
  }
};

class Solution {
 public:
  ListNode* mergeKLists(vector<ListNode*>& lists) {
    ListNode* head = new ListNode(0);
    ListNode* point = head;

    // Define priority queue with custom comparison function
    priority_queue<ListNode*, vector<ListNode*>, CompareNodes> q;

    // Push the heads of all lists into the priority queue
    for (ListNode* l : lists) {
      if (l) {
        q.push(l);
      }
    }

    // Merge the lists
    while (!q.empty()) {
      ListNode* node = q.top();
      q.pop();

      // Add the current smallest node to the merged list
      point->next = new ListNode(node->val);
      point = point->next;

      // Move the pointer of the current list forward
      node = node->next;

      // If there's remaining elements in the current list, push it to the
      // priority queue
      if (node) {
        q.push(node);
      }
    }

    return head->next;
  }
};

C++ Inheritance

Wed, 20 Mar 2024 02:59:13 -0400

class Base {
  public:
    int x;
  protected:
    int y;
  private:
    int z;
};

class PublicDerived: public Base {
  // x is public
  // y is protected
  // z is not accessible from PublicDerived
};

class ProtectedDerived: protected Base {
  // x is protected
  // y is protected
  // z is not accessible from ProtectedDerived
};

class PrivateDerived: private Base {
  // x is private
  // y is private
  // z is not accessible from PrivateDerived
};

Templates

Sat, 16 Mar 2024 14:23:52 -0400

#define pb push_back
#define fi first
#define se second
#define mp make_pair

using namespace std;

typedef pair<int, int> PII;
typedef long long LL;

template <typename T> bool chkMax(T &x, T y) { return (y > x) ? x = y, 1 : 0; }
template <typename T> bool chkMin(T &x, T y) { return (y < x) ? x = y, 1 : 0; }

Algo Note

Sun, 11 Feb 2024 03:10:46 -0400

Templates
#

Binary Search 二分法
#

使用条件

Angular

Sat, 27 Jan 2024 02:54:24 -0400

How to read source code in Github
#

Node and Angular Version Control
#

Check Current Angular and Node.js Versions
#

node -v
ng version

Upgrade or Downgrade Angular
#

ng update @angular/cli @angular/core

npm uninstall @angular/cli @angular/core
npm install @angular/cli@12 @angular/core@12

Reinstall Node Modules
#

After upgrading or downgrading Angular, it’s a good practice to remove the node_modules folder and reinstall dependencies to ensure everything works with the new version:

rm -rf node_modules
npm install

Concepts
#

template reference variable
#

Useful: child component can interact with or manipulate the parent’s HTMLElement

<input #text />
<app-child [inputRef]="text"></app-child>

child component use @Input to receive the reference of HTMLInputElement

React

Thu, 25 Jan 2024 22:33:37 -0400

Create a project
#

npm create vite@latest project-folder-name

Shortcuts
#

// rafce
// rafc
// rfc

Note: Tutorials 1
#

Note: Tutorials 2
#

Project: React Jobs (along with Tutorial 2)
#

create a project, update vite.config.ts

OOP Python

Mon, 01 Jan 2024 02:15:52 -0500

Leetcode 380. Insert Delete GetRandom O(1)
#

leetcode 380

from random import choice
class RandomizedSet():
    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.dict = {}
        self.list = []

        
    def insert(self, val: int) -> bool:
        """
        Inserts a value to the set. Returns true if the set did not already contain the specified element.
        """
        if val in self.dict:
            return False
        self.dict[val] = len(self.list)
        self.list.append(val)
        return True
        

    def remove(self, val: int) -> bool:
        """
        Removes a value from the set. Returns true if the set contained the specified element.
        """
        if val in self.dict:
            # move the last element to the place idx of the element to delete
            last_element, idx = self.list[-1], self.dict[val]
            self.list[idx], self.dict[last_element] = last_element, idx
            # delete the last element
            self.list.pop()
            del self.dict[val]
            return True
        return False

    def getRandom(self) -> int:
        """
        Get a random element from the set.
        """
        return choice(self.list)

OOP Java

Mon, 01 Jan 2024 02:15:48 -0500

Leetcode 380. Insert Delete GetRandom O(1)
#

leetcode 380

class RandomizedSet {
  Map<Integer, Integer> dict;
  List<Integer> list;
  Random rand = new Random();

  /** Initialize your data structure here. */
  public RandomizedSet() {
    dict = new HashMap();
    list = new ArrayList();
  }

  /** Inserts a value to the set. Returns true if the set did not already contain the specified element. */
  public boolean insert(int val) {
    if (dict.containsKey(val)) return false;

    dict.put(val, list.size());
    list.add(list.size(), val);
    return true;
  }

  /** Removes a value from the set. Returns true if the set contained the specified element. */
  public boolean remove(int val) {
    if (! dict.containsKey(val)) return false;

    // move the last element to the place idx of the element to delete
    int lastElement = list.get(list.size() - 1);
    int idx = dict.get(val);
    list.set(idx, lastElement);
    dict.put(lastElement, idx);
    // delete the last element
    list.remove(list.size() - 1);
    dict.remove(val);
    return true;
  }

  /** Get a random element from the set. */
  public int getRandom() {
    return list.get(rand.nextInt(list.size()));
  }
}

OOP C++

Mon, 01 Jan 2024 02:12:46 -0500

Leetcode 380. Insert Delete GetRandom O(1)
#

leetcode 380

// #include <cstdlib>
// #include <ctime>
// #include <unordered_map>
// #include <vector>

class RandomizedSet {
 private:
  std::unordered_map<int, int> dict;
  std::vector<int> list;
  // std::rand rand;

 public:
  /** Initialize your data structure here. */
  RandomizedSet() { std::srand(std::time(0)); }

  /** Inserts a value to the set. Returns true if the set did not already
   * contain the specified element. */
  bool insert(int val) {
    if (dict.find(val) != dict.end()) return false;

    dict[val] = list.size();
    list.push_back(val);
    return true;
  }

  /** Removes a value from the set. Returns true if the set contained the
   * specified element. */
  bool remove(int val) {
    if (dict.find(val) == dict.end()) return false;

    int lastElement = list.back();
    int idx = it->second;

    list[idx] = lastElement;
    dict[lastElement] = idx;

    list.pop_back();
    dict.erase(val);

    return true;
  }

  /** Get a random element from the set. */
  int getRandom() { return list[std::rand() % list.size()]; }
};

Spring6

Wed, 27 Dec 2023 10:03:16 -0500

IoC: Inverse of Control
#

let Spring manage creating objects

AOP: Aspect Orientied Programming
#

enhance the code functionality without modifying the source code

Spring Boot

Wed, 27 Dec 2023 09:02:18 -0500

Spring bean
#

an instance of a class managed by the Spring container

show all default beans
#

  // within main method
  ApplicationContext apc = SpringApplication.run(ClassName.class)
  for (String s : apc.getBeanDefinitionNames()) {
    System.out.println(s);
  }

Spring container
#

part of the core of the Spring framework
managing all beans: it decides when to create this instance, when to kill this instance, and how to initialize the instance, etc.
performs dependency injection

IoC(Inversion of Control)
#

instead of the programmer really deciding the flow of the application, deciding what objects are created, etc.
this all handed over to the Spring framework(or more precisely to the Spring container)

Dependency Injection
#

IoC entails Dependency Injection

Poetry

Wed, 13 Dec 2023 23:55:00 -0500

Install poetry
#

pip install poetry

Create a new project
#

# in work directory
poetry new name_of_project

Manage dependencies
#

1. modify pyproject.toml
#

[tool.poetry.dependencies]
scikit-learn = "*"

2. CLI
#

poetry add pytest

best practice for testing dependencies
#

[tool.poetry.group.dev.dependencies]
pytest = "^7.2.1"
pytest-mock = "*"

Activate environment in terminal
#

# activate
poetry shell
# deactivate
exit

Install dependencies specified in pyproject.toml file, or .lock file
#

poetry install

Run with Poetry-configured Env via CLI
#

poetry run python xxx.py

Building a library
#

poetry build

Publish to PyPI
#

poetry publish –r private-repository-location

Pytest

Wed, 13 Dec 2023 23:22:40 -0500

Pytest
#

1. for files whose name leading with test_
#

pytest

2. for single file the name of functions leading with `test_`
#

def test_fun1():
    assert 1 == 3

run pytest
#

python -m pytest XXX.py

Spark Core

Sun, 03 Dec 2023 19:43:27 -0500

RDD
#

Resilient distributed dataset
1. Fault tolerance
2. distributed
3. immutable data structure, stored in disk or memory
There are multiple partitions(#partitions is the same as #machines) within one RDD
DN(Data Node to store data) and Worker(to compute) are all in one machine(best practice)
- only shuffle need data transfering with network, others are in local machine

reduceByKey
#

hadoop ---> (hadoop, 1)
hadoop ---> (hadoop, 1)
hadoop ---> (hadoop, 1)
hive ---> (hive, 1)
hive ---> (hive, 1)
hive ---> (hive, 1)

reduceByKey

<hadoop, [1, 1, 1]>
<hive, [1, 1, 1]>

shuffle

hash(hadoop) ---> hashcode % 3 = 1(machine 1)
hash(hive) ---> hashcode % 3 = 2(machine 2)

operations
#

transformation: RDD–>RDD
#

Operations	Summary
map	return a new RDD
filter	return a new RDD; true: keep, false: remove
flatMap	map + flat(from two dimentional to one dimentional)
groupByKey
reduceByKey	groupByKey(get <hadoop, [1, 1, 1]>) + map(get <hadoop, 3>)
sortByKey	not default in spark, but default in hadoop
join	cogroup + remove nulls: join by key of <key, value>, all pairs will handle by cutomized function
cogroup	full join

action: RDD–>anything else
#

Operations	Summary
reduce	operation on all elements within RDD, first merges with second element, and then the result merges with the third element, …
collect	get all elements within RDD to local client
count	get the total number of elements within RDD
take(n)	get first unsorted n elements within RDD, top(n) can have first sorted n elements
takeOrdered(n, [ordering])	get first sorted n elements within RDD using natural order or a custom comparator
saveAsTextFile	save to file, each element with toString method
countByKey
foreach	iterate each element within RDD

Depencencies(This topic is Transformation operation related)
#

Hadoop

Sat, 02 Dec 2023 17:40:22 -0500

Path
#

/opt/module

HDFS
#

bin/hdfs namenode -format
sbin/start-all.sh
bin/hadoop fs -mkdir /usr
bin/hadoop fs -mkdir /usr/yixianwang
bin/hadoop fs -put demo.csv /usr/yixianwang
sbin/stop-all.sh

Spark

Fri, 01 Dec 2023 00:32:23 -0500

Basics
#

application > job > state > task
cluser manager: scheduling spark applications. e.g. yarn/mesos
- masater && worker
  - master: RM(ResourceManager in YARN)
  - worker: NM(NodeManager in YARN)
- executor: Container in YARN
driver:
- running in spark, including DAGScheduler && TaskScheduler
- combine operations and form DAG(directed acyclic graph)
- break down job into stages
- similar to ApplicationMaster(AM) in YARN, responsible for applying resources and scheduling
- DAGScheduler:
  - split job into stages
- TaskScheduler:
  - similar to AM, responsible for applying resources and scheduling
YARN: ResourceManager(RM), NodeManager(NM), ApplicationMaster(AM), Container
YARN: only NM can start AM and Container
Standalone: master, worder, driver, executor
Standalone: only worker can start driver and executor

Operating Mode
#

local/local-cluster/standalone/yarn/mesos

local
#

driver + executor, running in one process

Cassandra

Wed, 29 Nov 2023 21:56:01 -0500

Basics
#

replication factor (RF)
consistency level (CL) = QUORUM (Quorum referring to majority, 2 replicas in this case or RF/2 +1)
coordinator
SSTable
memtable
timestamps
compaction: take small SSTables and merging them into bigger one

Intro
#

keyspaces:

top-level namespace/container
similar to a relational database schema

CREATE KEYSPACE killrvideo
WITH REPLICATION = {
  'class': 'SimpleStrategy',
  'replication_factor': 1
};

USE switches between keyspaces
```
USE killrvideo;
```

Tables:

keyspaces contain tables
tables contain data

CREATE TABLE table1 (
  column1 TEXT,
  column2 TEXT,
  column3 INT,
  PRIMARY KEY (column1)
);

CREATE TABLE users (
  user_id UUID,
  first_name TEXT,
  last_name TEXT,
  PRIMARY KEY (user_id)
);

Basic Data Types:
- text: UTF8 encoded string, varchar is same as text, unbounded
- int: Signed, 32 bits
- timestamp: date and time, 64 bit integer, store number of seconds since Jan 1st 1970 GMT
UUID && TIMEUUID
- generate global unique id without communication between nodes
- TIMEUUID embeds a TIMESTAMP value

INSERT:

INSERT INTO users (user_id, first_name, last_name)
VALUES (uuid(), 'Joseph', 'Chu');

SELECT:

SELECT *
FROM users;

SELECT first_name, last_name
FROM users;

SELECT * 
FROM users
WHERE user_id = 4b516b3-ddf0-4c43-bab6-b91d674b64a5;

COPY:

imports/exports CSV

COPY table1 (column1, column2, column3) FROM 'table1data.csv';

header parameter skips the first line in the file

COPY table1 (column1, column2, column3) FROM 'table1data.csv'
WITH HEADER=true;

get data into Cassandra:
- COPY
- Spark
- Drivers
- Etc.

[C++ Concurrency in Action 2nd Edition by Anthony W.] Reading Note

Thu, 23 Nov 2023 17:51:57 -0500

Chapter 1: Introduction
#

concurrency
processor(including processing unit(or core))
task switching
context switch
hardware threads

1.1 Concurrency
#

In computer system, concurrency is about two or more indenpendent activites happening at the same time.
Sometimes, people also referring task switching is concurrency, but it’s an illusion of concurrency. In a single-core scenario, the operating system do some scheduling to divide the different tasks into chunks, and then the chunks from different tasks are interleaved. Task switching also involves context switching, it just saves and reloads some CPU state and instruction pointers.
The number of hardware threads is an important factor. It describes how many independent tasks the hardware can run concurrently.

approaches to concurrency
#

multiple single-threaded processes:
- pass messages to each other through normal interprocess communication channels (signals, sockets, files, pipes, and so on)
  - OS provides many protections between processes to avoid one process accidentally modifying data belonging to another process.
  - Inherent overhead: it takes some time to start a process.
- cons: such communication is often complicated to set up or slow, or both
- pros: easier to write safe concurrent code
multithreaded process(favored):
- Shared memory: all threads in a process share the same address space, and most of the data can be accessed directly from the all threads. (global variables remain global, pointers or references to objects or data can be passed around among threads)
- cons: flexibility - we must ensure that the view of the data seen by each thread is consistent whenever it’s accessed.
- pros: low overhead

concurrency vs. parallelism
#

separation of concerns and performance

Google Test

Thu, 09 Nov 2023 20:44:40 -0500

Install without Homebrew
#

git clone https://github.com/google/googletest
cd googletest
mkdir build
cd build
cmake ..
make
make install

-lgtest -lgtest_main -pthread

Example
#

#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <tuple>

#define print(x) std::ranges::copy(x, std::ostream_iterator<int>(std::cout, " ")); std::cout << std::endl

namespace testing {

TEST(Testname, Subtest_1) {
  int vali = 1;
  ASSERT_TRUE(vali == 1);

  std::vector<int> vec{5, 10, 15};
  EXPECT_THAT(vec, ElementsAre(5, 10, 15));

  std::string vals = "apple";
  EXPECT_STREQ(vals.c_str(), "apple");

  std::tuple<int, std::string, double, std::vector<int>> my_tuple{7, "hello world", 1.2, vec};
  EXPECT_THAT(my_tuple, FieldsAre(Ge(0), HasSubstr("hello"), Eq(1.2), ElementsAre(5, 10, 15)));

  int a;
  std::string b;
  std::tie(a, b, std::ignore, std::ignore) = my_tuple;
  std::cout << std::get<2>(my_tuple) << std::endl;

}

} // namespace testing

int main(int argc, char **argv) {
  testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
}

Docker

Thu, 09 Nov 2023 01:33:02 -0500

1. –help
#

docker --help anything

2. install
#

brew install docker --cask
docker run --rm hello-world

3. Create a docker container: long version
#

3.1 container
#

docker container create ###
docker container create hello-world:linux # Does not start containers

3.2 list container we have created
#

docker ps
docker ps --all

3.3 start container
#

docker container start DockerID

3.4 log
#

3.4.1 Approach 1
#

docker logs *** # with first three characters of DockerID

3.4.2 Approach 2: even if the container already started
#

docker container start --attach ***

4. Create a docker container: short version
#

docker run hello-world:linux

docker run = docker container create + docker container start + docker container attach

Airflow

Wed, 08 Nov 2023 20:41:27 -0500

Official Doc

Components of Apache Airflow
#

Web Server
Scheduler
Metadata Database
Executor

Commandlines
#

python3 -m venv env_airflow
source ./env_airflow/bin/activate
airflow db init
cd ~/airflow
mkdir dags
airflow webserver

Create users
#

airflow users create --role Admin --username username --email email --firstname firstname --lastname lastname --password password

Start scheduler
#

# any folder
airflow scheduler

Template PI

Sat, 04 Nov 2023 17:51:02 -0400

// 138 subarray_sum
// 1. Official solution:
#include <vector>
#include <numeric>
#include <iostream>
#include <cassert>
#include <unordered_map>

#define assertm(exp, msg) assert(((void)msg, exp))
#define print(input) for (auto& elem : input) std::cout << elem << std::endl

class Solution {
 public:
  std::vector<int> subarraySum(std::vector<int>& nums) {
    std::vector<int> result;

    // 
    std::unordered_map<int, int> hash_table = {{0, -1}};
    int sum = 0;
    for (int i = 0; i < nums.size(); ++i) {
      sum += nums[i];
      if (hash_table.find(sum) != hash_table.end()) {
        result.push_back(hash_table[sum] + 1);
        result.push_back(i);
        break;
      }
      hash_table[sum] = i;
    }
    return result;
  }
};

int main() {
  Solution solution = Solution();
  std::vector<int> input{1, 0, 1};
  std::vector<int> expect_output{1};
  std::vector<int> output = solution.subarraySum(input);

  print(output);
  assertm(output == expect_output, "wrong answer");
}

/*
// 2. Mine solution: excced time limitation
#include <vector>
#include <numeric>
#include <iostream>
#include <cassert>

#define assertm(exp, msg) assert(((void)msg, exp))

class Solution {
 public:
  std::vector<int> subarraySum(std::vector<int>& nums) {
    std::vector<int> result;
    if (nums.size() == 0) {
      return result;
    }
    int size = nums.size();
    if (size == 1 && nums[0] == 0) {
      return nums;
    }
    for (int left = 0; left < size - 1; ++left) {
      if (nums[left] == 0) {
        result.push_back(left);
        result.push_back(left);
        return result;
      }
      for (int right = left + 1; right < size; ++right) {
        if (accumulate(nums.begin() + left, nums.begin() + right + 1, 0) == 0) {
          result.push_back(left);
          result.push_back(right);
          return result;
        }
      }
    }
    return result;
  }
};

int main() {
  Solution solution = Solution();
  std::vector<int> input{1, 0, 1};
  std::vector<int> expect_output{1};
  std::vector<int> output = solution.subarraySum(input);
  assertm(solution.subarraySum(input) == expect_output, "Hello assert");
}
*/

MySQL

Fri, 03 Nov 2023 17:51:02 -0400

Common command
#

mysql -u root -p
password:xxxx0000

create database xxxx character set utf8mb4;
drop database xxxx;

use xxxx;
source pathto.sql;

Schemas
#

Fact and dimension tables are organized in particular structures known as schemas.

Star schema && Snowflake schema
#

Star schema and snowflake schema are popular ways of organising this information.

Trie Techlead

Fri, 03 Nov 2023 17:51:02 -0400

#! python

class Node:
  def __init__(self, children, is_word):
    self.children = children
    self.is_word = is_word

class Solution:
  def __init__(self):
    self.trie = None

  def build(self, words):
    self.trie = Node({}, False)
    for word in words:
      current = self.trie
      for char in word:
        if not char in current.children:
          current.children[char] = Node({}, False)
        current = current.children[char]
      current.is_word = True

  def autocomplete(self, prefix):
    current = self.trie
    for char in prefix:
      if not char in current.children:
        return []
      current = current.children[char]
    return self._dfs_helper(current, prefix)
  
  def _dfs_helper(self, node, prefix):
    result = []
    if node.is_word:
      result += [prefix]
    for char in node.children:
      result += self._dfs_helper(node.children[char], prefix + char) 
    return result

s = Solution()
s.build(['dog', 'dark', 'cat', 'door', 'dodge', 'doddddd'])
print(s.autocomplete('do'))
# ['dog', 'door', ''dodge]

AWS

Tue, 24 Oct 2023 03:10:46 -0400

scp -ri /Users/xxxxxxxxxx/.ssh/xxx_xx.pem ./local_foler ec2-user@ec2-22-222-22-222.us-east-2.compute.amazonaws.com:~/

Colab Tips

Tue, 24 Oct 2023 03:10:46 -0400

colab tips Seems like colab is popular, so I wanted to share maybe some useful tips that helped me streamline my setup/workflow:

a) If you cloned the notebook and are using gdrive to store the data, you can only mount gdrive using the python package, which requires entering a new oauth code for each session; if you create a new notebook, it actually persists the mount between sessions. You can just copy the contents over - https://datascience.stackexchange.com/questions/64486/how-to-automatically-mount-my-google-drive-to-google-colab

Colab Upload

Tue, 24 Oct 2023 03:10:46 -0400

import os
from getpass import getpass
import urllib

user = input('User name: ')
password = getpass('Password: ')
password = urllib.parse.quote(password) # your password is converted into url format
repo_name = "gregdurrett/nlp-qa-finalproj.git"
cmd_string = 'git clone https://{0}:{1}@github.com/{2}'.format(user, password, repo_name)

!{cmd_string}

Conda

Tue, 24 Oct 2023 03:10:46 -0400

Basics
#

conda env list
conda create -n env_name python=3.11 --no-default-packages
conda env remove -n ENV_NAME

Export to yml file
#

# after conda activate env_name
conda export env > env_test.yml

Create env with yml file
#

conda env create –f xxx.yml

Make a copy of a conda environemnt
#

conda create --clone env_name -n new_env_name

Upgrade package
#

pip install <package_name> --upgrade

Update conda to the current version
#

conda update conda

CUDA

Tue, 24 Oct 2023 03:10:46 -0400

Which machine learning algorithms can be optimized with CUDA?
#

CUDA (Compute Unified Device Architecture) is a parallel computing platform and application programming interface (API) created by NVIDIA for utilizing their GPUs (Graphics Processing Units) to accelerate various computational tasks, including machine learning. Many machine learning algorithms can be optimized with CUDA to take advantage of GPU parallelism, which can significantly speed up training and inference. Here are some common machine learning algorithms that can benefit from CUDA optimization:

Data Science Knowledge

Tue, 24 Oct 2023 03:10:46 -0400

Bias vs Variance
#

Low Bias(very sensitive to the training data), (then it performs poorly when we got new data)High Variance – Overfitting
Higher Bias(less sensitive to the training data), (then it performs better when we got new data)Low Variance – Underfitting
Error = bias^2 + variance + inreducible error
The best model is where the error is reduced

Django

Tue, 24 Oct 2023 03:10:46 -0400

//0 virtualenv dj

cd dj

pip install django

django-admin startproject reports_proj

python manage.py migrate

python manage.py createsuperuser

python manage.py startapp sales

python manage.py startapp reports

python manage.py startapp profiles

python manage.py startapp products

python manage.py startapp customers

python manage.py runserver http://127.0.0.1:8000/ //10 pip install pillow django-crispy-forms matplotlib seaborn pandas xhtml2pdf pip freeze pip freeze > requirements.txt

//15

settings.py

Application definition
#

INSTALLED_APPS = [ …

Git

Tue, 24 Oct 2023 03:10:46 -0400

We Want to Keep the Files Locally Modified but Unstaged
#

If you want to keep local changes without staging them for commits:

git update-index --assume-unchanged config1.yml
git update-index --assume-unchanged config2.yml
git update-index --assume-unchanged config3.yml

These files will not appear in git status anymore.
They will remain untracked in future commits but still exist locally. To revert this and track them again:

git update-index --no-assume-unchanged config1.yml
git update-index --no-assume-unchanged config2.yml
git update-index --no-assume-unchanged config3.yml

list files in –assume-unchanged

git config --global alias.hidden '!git ls-files -v | grep "^[a-z]"'

We Never Want to Accidentally Modify These Files
#

If these files are in the repository but should never be changed on your local machine, use:

git update-index --skip-worktree config1.yml
git update-index --skip-worktree config2.yml
git update-index --skip-worktree config3.yml

This tells Git to ignore future changes in these files unless you explicitly change them. To undo this and allow modifications again:

git update-index --no-skip-worktree config1.yml
git update-index --no-skip-worktree config2.yml
git update-index --no-skip-worktree config3.yml

git.config
#

$ cat .gitconfig
[alias]
        lg = log --oneline --graph --decorate --all
        lgt = log --pretty=format:'%h %an %ar %ad %s' --date=iso --all --graph
        hidden = !git ls-files -v | grep \"^[a-z]\"

branch operations
#

# set the remote branch to track the local branch
git push --set-upstream origin branchb

# check upstream branch
git branch -vv

# change upstream branch later
git branch -u origin/branch-name

# delete a branch
git branch -d <branch-name>

# create a new branch
git checkout -b <branch-name>
git switch -c <branch-name>

# rename branch
git branch -m <new name>

tag is a snapshot of all the commits at that time
#

# create a tag, -a means annotation, 
git tag -a v1.0.0 -m "version 1.0.0"
git tag
git push origin v1.0.0

# pull latest code and tag again
git pull
git tag
git tag -a v1.0.1 -m "version 1.0.1"
git tag
git push origin v1.0.1

merge, on development branch, do operations to merge feature branch into development branch
#

# merge feature branch into development branch, locally
git checkout development
git merge feature-branch

# merge development branch into feature branch, without tracking development locally
git checkout feature-branch
git fetch origin
git merge origin/development

# conflict content will show message like:
# CONFLICT (content): Merge conflict in some-file.js

# resolve conflict, stage, commit, and then push
# git commit -m "Resolved merge conflicts between development and feature-branch"

rebase
#

git checkout feature-branch
git pull --rebase origin development

# If conflicts occur, resolve them and continue rebasing:
git rebase --continue

# After rebasing, force push since history is rewritten:
git push --force origin feature-branch

git diff
#

git diff remote-origin/branch-name # compare local with remote

Semantic Commit Messages
#

See how a minor change to your commit message style can make you a better programmer.

Google Cloud

Tue, 24 Oct 2023 03:10:46 -0400

Connect to Google cloud
#

ssh -i ~/.ssh/xxxxxx xxxxxxxxxx@33.333.3.333

Generate ssh keys
#

ssh-keygen -t rsa -f ~/.ssh/xxxxxx -C “xxxxxx”

copy files from local to server
#

scp -i ~~/.ssh/my-ssh-key LOCAL_FILE_PATH USERNAME@IP_ADDRESS:~~ scp -i ~~/.ssh/my-ssh-key -r LOCAL_FOLDER_PATH USERNAME@IP_ADDRESS:~~

Hexo

Tue, 24 Oct 2023 03:10:46 -0400

Doc
#

Doc
Restart hexo server, each time changed yml file

NEW BLOG PROJECT
#

hexo init blog_project_name

POST
#

creating a post
#

# under blog folder to create a new post with name a.md
hexo new a

DRAFT
#

create a new draft
#

hexo new draft b

test draft
#

hexo server --draft

publish the draft
#

# move b from _drafts folder to _posts folder
hexo publish b

PAGE
#

hexo new page c

to access the page c “http://localhost:4000/about/”

SCAFFOLDS
#

For handling default content

Hugo

Tue, 24 Oct 2023 03:10:46 -0400

Theme Doc - hextra
#

hextra doc

Theme-hextra
#

hextra

# an easy way?
hugo serve -D -t theme_name_here

# Change directory to the theme folder
cd hextra-starter-template

# Start the server
hugo mod tidy
hugo server --logLevel debug --disableFastRender -p 1313

# Update the theme
hugo mod get -u
hugo mod tidy

# start the server for draft
hugo server -D

Installing on mac
#

brew install hogo

Creating
#

hugo new site first_site

Installing & using themes
#

# within config.toml
theme = "the name of theme downloaded"

content
#

hugo new a.md

List pages: if the folder is not the first folder level under content
#

# it must to be _index.md here
hugo new dir1/dir2/_index.md

archetypes
#

find if there exist the folder name within archetypes that correspond with the folder name within content
yes: use the specific markdown file; no: use the default.md

Shortcodes
#

# /{/{/< shortcode-name param1 />/}/}
# e.g.
# /{/{/< youtube AnyYoutubeID />/}/}

Tags & Categories
#

tags: ["tag1", "tag2", "tag3"]
categories: ["cat1"]

Creating taxonomy
#

Notice: modify themes/ga-hugo-theme/layouts/_default/list.html by adding a new line for that name mood

mood: ["happy", "upset"]

# hugo.toml
# even if tag and category are default, but we have to include them when we creating new taxonomies
# after modifyint he toml file, restart the server
[taxonomies]
  tag = "tags"
  category = "categories"
  mood = "moods"

Setting up Github Page
#

Cretea production repository
#

the repository’s name has to be username.github.io
it at least has one commit

git clone git@github.com:yixianwang/yixianwang.github.io.git
cd yixianwang.github.io
git checkout -b main
touch README.md
git status
git add .
git commit -m "adding readme"
git push origin main

Add submodule
#

Head to yixian-site folder

git submodule add -b main git@github.com:yixianwang/yixianwang.github.io.git public

Deploy the site
#

Generate public folder with static website
#

hugo # without draft
hugo -D # with draft
# or
# hugo -t theme_name

Push
#

Head to public folder

git add .
git commit -m "update"
git push origin main

Java

Tue, 24 Oct 2023 03:10:46 -0400

Java Version
#

To check all java version: /usr/libexec/java_home -V
and then select specific version of java within .zshrc
for spark and hadoop: 1.8.0_391 export JAVA_HOME=$(/usr/libexec/java_home -v 1.8.0_391)
for sprint boot: 21.0.1 export JAVA_HOME=$(/usr/libexec/java_home -v 21.0.1) export PATH=$PATH:$JAVA_HOME

Interface
#

Java接口(Interface)是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为。打一个比方，接口好比一个戏中的角色，这个角色有一些特定的属性和操作，然后实现接口的类就好比扮演这个角色的人，一个角色可以由不同的人来扮演，而不同的演员之间除了扮演一个共同的角色之外，并不要求其它的共同之处。

常用的Interface:
#

Set
#

Set注重独一无二,该体系集合可以知道某物是否已经存在于集合中,不会存储重复的元素。Set的实现类在面试中常用的是：HashSet 与 TreeSet

Legacy Algo Note

Tue, 24 Oct 2023 03:10:46 -0400

Algorithm Template: 1. Binary Search 2. Two Pointers 3. Sorting 4. Binary Tree Divide & Conquer 5. BST Iterator 6. BFS 7. DFS 8. Dynamic Programming 9. Heap 10. Union Find 11. Trie

Data structures: 1. Array 2. Queue 3. Linked List 4. Binary Tree 5. Hash Map 6. Stack 7. Heap(PriorityQueue) 8. Union Find 9. Trie 10. Deque 11. Monotone Stack

Coding style: 1. check availability of input java: if (nums == null || nums.length == 0) {return -1} python: if not nums: # nums is None or len(nums) == 0 return -1 2. variables’ name 3. space 4. indentation

Linear Algebra

Tue, 24 Oct 2023 03:10:46 -0400

学堂链接
线性代数是否可解 <=> 等价于常熟向量是否能够表示成系数向量的线性组合

OOD

Tue, 24 Oct 2023 03:10:46 -0400

Friendship Service
#

class FriendshipService:
    
    def __init__(self):
        # do intialization if necessary
        self.follower = dict()
        self.following = dict()
   
    def getFollowers(self, user_id):
        # write your code here
        if user_id not in self.follower:
            return []

        return sorted(list(self.follower[user_id]))

    def getFollowings(self, user_id):
        # write your code here
        if user_id not in self.following:
            return []

        return sorted(list(self.following[user_id]))

    def follow(self, to_user_id, from_user_id):
        # write your code here
        if to_user_id not in self.follower:
            self.follower[to_user_id] = set()
        self.follower[to_user_id].add(from_user_id)

        if from_user_id not in self.following:
            self.following[from_user_id] = set()
        self.following[from_user_id].add(to_user_id)


    def unfollow(self, to_user_id, from_user_id):
        # write your code here
        if to_user_id in self.follower:
            if from_user_id in self.follower[to_user_id]:
                self.follower[to_user_id].remove(from_user_id)
        
        if from_user_id in self.following:
            if to_user_id in self.following[from_user_id]:
                self.following[from_user_id].remove(to_user_id)

Python

Tue, 24 Oct 2023 03:10:46 -0400

Typing
#

from typing import reveal_type

Logging
#

V0
#

import logging
logging.basicConfig(level=logging.INFO)
logging.info("Just an information")

V1
#

# importing module
import logging

# Create and configure logger
logging.basicConfig(filename="newfile.log",
					format='%(asctime)s %(message)s',
					filemode='w')

# Creating an object
logger = logging.getLogger()

# Setting the threshold of logger to DEBUG
logger.setLevel(logging.DEBUG)

# Test messages
logger.debug("Harmless debug Message")
logger.info("Just an information")
logger.warning("Its a Warning")
logger.error("Did you try to divide by zero")
logger.critical("Internet is down")

Python Scripts

Tue, 24 Oct 2023 03:10:46 -0400

Add sentences to the beginning of all markdown files
#

import os

# Define the sentence you want to add
sentence_to_add = """+++
title = 'Markdown'
date = 2023-10-23T21:50:46-04:00
draft = true
+++
\n"""

# Specify the directory where your Markdown files are located
markdown_directory = "./"

# List all the Markdown files in the directory
markdown_files = [f for f in os.listdir(markdown_directory) if f.endswith(".md")]

# Loop through each Markdown file and add the sentence
for markdown_file in markdown_files:
    file_path = os.path.join(markdown_directory, markdown_file)
    
    # Open the file in read mode to read its content
    with open(file_path, 'r') as file:
        content = file.read()
    
    # Open the file in write mode to add the sentence at the beginning
    with open(file_path, 'w') as file:
        file.write(sentence_to_add)
        file.write(content)

print("Sentences added to Markdown files.")

Automatically create branches based on ticket number
#

import subprocess

def create_branch(ticket_number, description):
    branch_name = f"feature/{ticket_number}-{description.replace(' ', '-').lower()}"
    subprocess.run(['git', 'checkout', '-b', branch_name])
    print(f"Branch '{branch_name}' created and checked out.")

# Example usage
create_branch('PROJ-1234', 'add user authentication')

Pre-Commit Hook for Quality Checks (e.g., Linting)
#

Create .git/hooks/pre_commit_check.py file with:

#!/bin/bash
python3 .git/hooks/pre_commit_check.py

import subprocess

def run_linter():
    result = subprocess.run(['flake8', '.'], capture_output=True, text=True)
    if result.returncode != 0:
        print("❌ Lint errors detected. Commit aborted.")
        print(result.stdout)
        exit(1)
    else:
        print("✅ Linter check passed.")
        
if __name__ == "__main__":
    run_linter()

Make pre_commit_check.py executable:

chmod +x .git/hooks/pre_commit_check.py

Automated Pull, Merge, Push (One-Click Sync)
#

import subprocess

def sync_with_main():
    try:
        subprocess.run(['git', 'checkout', 'main'], check=True)
        subprocess.run(['git', 'pull', 'origin', 'main'], check=True)
        subprocess.run(['git', 'checkout', '-'], check=True)  # Go back to the original branch
        subprocess.run(['git', 'merge', 'main'], check=True)
        subprocess.run(['git', 'push'], check=True)
        print("✅ Synced with main and pushed changes.")
    except subprocess.CalledProcessError as e:
        print(f"❌ Error during sync: {e}")

sync_with_main()

Auto-Tagging and Version Bumping
#

Every time we merge to main, automatically bump version (semver) and create a new tag.

import subprocess
import re

def get_latest_version():
    result = subprocess.run(['git', 'tag'], capture_output=True, text=True)
    tags = result.stdout.split()
    tags = [t for t in tags if re.match(r'v\d+\.\d+\.\d+', t)]
    return sorted(tags)[-1] if tags else 'v0.0.0'

def bump_version(version):
    major, minor, patch = map(int, version.lstrip('v').split('.'))
    return f'v{major}.{minor}.{patch + 1}'

def tag_new_version():
    latest_version = get_latest_version()
    new_version = bump_version(latest_version)

    subprocess.run(['git', 'tag', new_version])
    subprocess.run(['git', 'push', 'origin', new_version])

    print(f"✅ Created and pushed new tag: {new_version}")

tag_new_version()

Read Env variables directly
#

import os

API_EMAIL = os.getenv("JIRA_EMAIL")
API_TOKEN = os.getenv("JIRA_API_TOKEN")

Utils Notebook

Tue, 24 Oct 2023 03:10:46 -0400

python utils
#

curl http://api.joind.in | python -mjson.tool

To MP3 Converter Free
#

cat *.mp3 > final.mp3

# best
brew install mp3wrap
mp3wrap output.mp3 *.mp3

pandoc convert markdown to org
#

pandoc -f markdown -t org -o note_dynamic_programming.org note_dynamic_programming.md

set in c++
#

#include <vector>
#include <numeric>
#include <iostream>
#include <cassert>
#include <unordered_map>
#include <unordered_set>
#include <set>

#include <iostream>
#include <queue>
#include <vector>
#include <set>
#include <map>


#define assertm(exp, msg) assert(((void)msg, exp))
#define print(input) for (auto& elem : input) std::cout << elem << std::endl

int main() {

  auto cmp = [](const std::pair<int, int>& a, const std::pair<int, int>& b) {return a.second < b.second;};

  std::set<std::pair<int, int>, decltype(cmp)> heap;

  heap.insert(std::make_pair(1, 3));
  heap.insert(std::make_pair(31, 1));
  heap.insert(std::make_pair(4, 4));
  heap.insert(std::make_pair(2, 2));
  heap.insert(std::make_pair(5, 5));


  auto it = heap.begin();
  it = std::next(it, 2);
  it = std::prev(it, 1);
  std::cout << it->first << " " << it->second << std::endl;

  int index = 31;
  auto it2 = std::find_if(heap.begin(), heap.end(), [index](const std::pair<int, int>& a) {return a.first == index;});
  heap.erase(it2);

  it = heap.begin();
  std::cout << it->first << " " << it->second << std::endl;

  return 0;
}

Enable/Disable Monitor
#

SwitchResX

0x3f3f3f3f && 0xcfcfcfcf
#

If you are using C++ to write program, sometimes you need to set an large number. We can use INT_MAX of course, however, sometimes we may get overflow if we add the large number by 1.

Vim

Tue, 24 Oct 2023 03:10:46 -0400

format code in Google style
#

gg=G

???others
#

:s/old_name/new_name/gc

Cpp Syntax Leetcode

Tue, 13 Oct 2020 22:57:08 -0400

Here’s a comprehensive list of essential C++ syntax and language knowledge you should master for solving coding problems efficiently on LeetCode — especially for interviews at top tech companies.

I’ve grouped them into Beginner → Intermediate → Advanced levels so you can build your mastery progressively.

🧱 1. Basic C++ Syntax & Structure (Fundamentals)
#

✅ Basic program structure

Notes on Yixian Wang

Latex

Claude Tips

.claude > TODO.md #

Architecture #

Tips #

CLAUD.md #

Daily workflow #

Power User #

TA

Time #

Grep

Alias for chekcing logs #

MEMO

pre-requisite #

.vscode/tasks.json #

.vscode/launch.json #

profile #

x #

UV

1) What uv is (why use it) #

2) Install uv #

3) Create & manage virtual environments #

Tar

The tar command — a practical, modern guide #

0) What tar is #

1) The 5 core verbs #

Springboot Exceptions

1) Let them bubble to the right boundary #

Rest Client

Github Repository #

File Upload #

Spring Boot Exception

USER #

Thoughts #

NLP

Milestones #

Magic

Terminology #

Rendercv

CLI #

LC 2025

References #

Problem List #

Data Structures #

Basic #

1. Enumerate the right, maintain the left. #

BRE Drools

Syntax #

General Syntax of the when block #

Virtual Thread

Platform threads #

Virtual threads #

Curl

Syntax #

Api testing with Scripts #

Vscode

Attach Java Debugger #

Vim setup #

Spring Boot Session

Example #

Result #

BackgroundController #

nvm

Redis

SETNX #

Parameters: #

Github Actions

File Structure #

Example #

Docker Example #

IDEA

Intellij SpringBoot DevTools Setup #

Debug #

Line Breakpoint (red circle) #

Method Breakpoint (red diamond) #

Field Watchpoint (red eye) #

Exception Breakpoint (red thunder) #

ideaVim #

Nx

.claude > TODO.md
#

Architecture
#

Tips
#

CLAUD.md
#

Daily workflow
#

Power User
#

Time
#

Alias for chekcing logs
#

pre-requisite
#

.vscode/tasks.json
#

.vscode/launch.json
#

profile
#

x
#

1) What uv is (why use it)
#

2) Install uv
#

3) Create & manage virtual environments
#

The `tar` command — a practical, modern guide
#

0) What `tar` is
#

1) The 5 core verbs
#

1) Let them bubble to the right boundary
#

Github Repository
#

File Upload
#

USER
#

Thoughts
#

Milestones
#

Terminology
#

CLI
#

References
#

Problem List
#

Data Structures
#

Basic
#

1. Enumerate the right, maintain the left.
#

Syntax
#

General Syntax of the when block
#

Platform threads
#

Virtual threads
#

Syntax
#

Api testing with Scripts
#

Attach Java Debugger
#

Vim setup
#

Example
#

Result
#

BackgroundController
#

SETNX
#

Parameters:
#

File Structure
#

Example
#

Docker Example
#

Intellij SpringBoot DevTools Setup
#

Debug
#

Line Breakpoint (red circle)
#

Method Breakpoint (red diamond)
#

Field Watchpoint (red eye)
#

Exception Breakpoint (red thunder)
#

ideaVim
#

helper
#

useful properties and tips
#

generate monorepo project
#

generate app
#

generate component/directive/pipe/service
#

generate library
#

NX Angular MFS
#

Find and Kill process
#

What
#

Mission
#

Goal
#

How
#

Pros
#

Work flow
#

Common Usage
#

Common Use Case
#

Resume bullet points
#

JWT
#

My advantages
#

Greetings
#

General Questions
#

Why are you interested in this role?
#

What do you know about our company?
#

Why are you leaving your current job?
#

Where do you see yourself in five years?
#