website·Indexed 29 days ago
https://qwertyvipul.ioA collection of technical notes and guides covering LeetCode solutions in Python and JavaScript, system design principles including the scalable monolith, and programming language fundamentals for Go, Rust, and JavaScript. Includes specific sections on OAuth, token-based authentication, and database types.
The scalable monolith architecture organizes code into layers with increasing authority. The primary goal is to ensure responsibilities remain explicit, execution flow is visible, and state changes are centralized.
Layer Definitions:
System design in software engineering is the process of translating specified requirements into a structured system for effective implementation. It involves defining five core elements:
The standard OAuth authentication flow involves delegating identity verification to a trusted provider (e.g., Google, Apple, Microsoft) and managing sessions via tokens:
To prevent replay attacks and limit the impact of a compromised token, implement refresh token rotation. When a refresh token is used to obtain a new access token, the backend should:
Promise.all to wait for all simulated API requests to resolve before calculating the totals per data center.const appNames = ["vmware", "kafka", "zookeeper"];
const dataCenters = [
{ name: "london", url: "ldn.api.com" },
{ name: "hongkong", url: "hk,api.com" },
{ name: "bangalore", url: "blr.api.com" },
];
// Mock database generation
const db = [];
for (const { name, url } of dataCenters) {
const entry = { name, url };
for (const appName of appNames) {
entry[appName] = {
protectedCount: Math.floor(Math.random() * 200) + 100,
unProtectedCount: Math.floor(Math.random() * 200) + 100,
};
}
db.push(entry);
}
// Simulate API call
const apiCall = (url, appName) => {
return new Promise((resolve) => {
const data = db.find((entry) => entry.url === url)[appName];
setTimeout(() => resolve(data), Math.random() * 2000 + 1000);
});
};
// Execute concurrent requests
const promises = [];
for (const { name, url } of dataCenters) {
for (const appName of appNames) {
promises.push(apiCall(url, appName).then((data) => ({ name, data })));
}
}
const res = {};
Promise.all(promises).then((values) => {
values.forEach(({ name: dataCenterName, data }) => {
if (!res[dataCenterName]) {
res[dataCenterName] = { totalProtectedCount: 0, totalUnprotectedCount: 0 };
}
res[dataCenterName].totalProtectedCount += data.protectedCount;
res[dataCenterName].totalUnprotectedCount += data.unProtectedCount;
});
console.log("Aggregated Results:", res);
});@functools.lru_cache decorator to memoize expensive functions in Python. This stores the results of function calls, returning the cached value when the same inputs occur again. You can specify the maxsize parameter to limit the number of entries in the cache.import functools
@functools.lru_cache(maxsize=4)
def expensive_function(n):
print(f"Calculating {n}...")
return n * npush() and shift() to implement a basic Queue (FIFO). Use unshift() to add to the front and shift() to remove from the front. Use slice() for non-destructive copying and splice() for modifying the original array.// Initialization
const arr = Array(n).fill(0);
const fromArray = Array.from(iterable);
// Queue operations
const q = [];
q.push(num); // Enqueue
const front = q.shift(); // Dequeue
// Array manipulation
arr.slice(startIdx, endIdx); // Returns new copy
arr.splice(startIdx, count); // Modifies original
// Summing an array
const sum = nums.reduce((acu, num) => acu + num, 0);elements() method to return an iterator over elements repeating each as many times as its count. Use most_common(n) to return a list of the n most frequent elements and their counts as tuples.import collections
counter = collections.Counter([1, 1, 2, 2, 3, 3, 3, 3])
# Get all elements as a list
elements = list(counter.elements())
print(elements) # Output: [1, 1, 2, 2, 3, 3, 3, 3]
# Get the 2 most common elements
most_common = counter.most_common(2)
print(most_common) # Output: [(3, 4), (1, 2)] (or similar depending on data)