https://www.youtube.com/watch?v=ybkkiGtJmkM&ab_channel=JaredOwen

How Enigma machine works

amor fati

I was referred to EPAM Systems and had a technical interview. It was much easier than I expected. Alhamdulillah, I got positive feedback.

The below are some of the questions:

JavaScript:
Var let const
Scope types
Object copy
Closures
Hoisting

HTML/CSS:
Semantic tags
Position types
Usage of preprocessors
Types of lists

Typescript:
Type vs interface
Type and interface conjunction
Utility types
Generics

ReactJs:
What's jsx
State management
Hooks and their usages
Component lifecycle

Practical:
Finding a bug in react code
Remove one of the duplicate words in a string

The bug 🪲

Be the best of your type

LeetCode (DSA) o'rganishni tartibi ekan,
Osonidan → Qiyiniga qarab:

1. Core Structures
— Array
— Stack
— Queue
— Linked List
— Hashmap
— Tree
— Graph
— Heap

2. Fundamental Patterns
— Sorting
— Two Pointers
— Sliding Window
— Binary Search
— Fast & Slow Pointers
— Prefix Sum
— Heap/Kth Problems

3. Core Problem Solving Patterns
— Divide & Conquer
— String Manipulation
— Linked List Tricks
— Tree Traversals
— Frequency Counting
— Expression Evaluation
— Monotonic Stack/Queue
— Merge Intervals
— Backtracking

4. Advanced Patterns
— Dynamic Programming
— Greedy
— Multi-pattern Problems (e.g., DP + Trie, Sliding Window + Heap)
— Graph Algorithms
— Interval Partitioning
— Design Problems (e.g., LRU Cache, Twitter, TinyURL)

(c) Manba

@Otabek_Kholmirzaev

OSPanel download with fast speed

Hamma AI’ni chuqurroq o‘rganish kerak deb aytayapti, to‘g‘ri.

Lekin Rustni ham e’tibordan chetda qoldirmaslik kerak.

Microsoft C va C++ kod bazalarini Rustga o‘tkazmoqda ekan, demak boshqa kompaniyalar ham baribir Microsoftga ergashadi. Rustga o‘tish asta-sekin ommalashadi.

Bu esa Rustni bilgan dasturchilar uchun ko‘p imkoniyatlar va ish o‘rinlari ochilishi demakdir.

2026-yilda Rustni o‘rganish kerak!

@Otabek_Kholmirzaev

✅ JavaScript Advanced Concepts You Should Know 🔍💻

These concepts separate beginner JS from production-level code. Understanding them helps with async patterns, memory, and modular apps.

1️⃣ Closures 
A function that "closes over" variables from its outer scope, maintaining access even after the outer function returns. Useful for data privacy and state management.

function outer() {
  let count = 0;
  return function inner() {
    count++;
    console.log(count);
  };
}
const counter = outer();
counter(); // 1
counter(); // 2

2️⃣ Promises & Async/Await 
Promises handle async operations; async/await makes them read like sync code. Essential for APIs, timers, and non-blocking I/O.

// Promise chain
fetch(url).then(res => res.json()).then(data => console.log(data)).catch(err => console.error(err));

// Async/Await (cleaner)
async function getData() {
  try {
    const res = await fetch(url);
    const data = await res.json();
    console.log(data);
  } catch (err) {
    console.error(err);
  }
}

3️⃣ Hoisting 
Declarations (var, function) are moved to the top of their scope during compilation, but initializations stay put. let/const are block-hoisted but in a "temporal dead zone."

console.log(x); // undefined (hoisted, but not initialized)
var x = 5;

console.log(y); // ReferenceError (temporal dead zone)
let y = 10;

4️⃣ The Event Loop 
JS is single-threaded; the event loop processes the call stack, then microtasks (Promises), then macrotasks (setTimeout). Explains why async code doesn't block.

5️⃣ this Keyword 
Dynamic binding: refers to the object calling the method. Changes with call site, new, or explicit binding.

const obj = {
  name: "Sam",
  greet() {
    console.log(`Hi, I'm ${this.name}`);
  },
};
obj.greet(); // "Hi, I'm Sam"

// In arrow function, this is lexical
const arrowGreet = () => console.log(this.name); // undefined in global

6️⃣ Spread & Rest Operators 
Spread (...) expands iterables; rest collects arguments into arrays.

const nums = [1, 2, 3];
const more = [...nums, 4]; // [1, 2, 3, 4]

function sum(...args) {
  return args.reduce((a, b) => a + b, 0);
}
sum(1, 2, 3); // 6

7️⃣ Destructuring 
Extract values from arrays/objects into variables.

const person = { name: "John", age: 30 };
const { name, age } = person; // name = "John", age = 30

const arr = [1, 2, 3];
const [first, second] = arr; // first = 1, second = 2

8️⃣ Call, Apply, Bind 
Explicitly set 'this' context. Call/apply invoke immediately; bind returns a new function.

function greet() {
  console.log(`Hi, I'm ${this.name}`);
}
greet.call({ name: "Tom" }); // "Hi, I'm Tom"

const boundGreet = greet.bind({ name: "Alice" });
boundGreet(); // "Hi, I'm Alice"

9️⃣ IIFE (Immediately Invoked Function Expression) 
Self-executing function to create private scope, avoiding globals.

(function() {
  console.log("Runs immediately");
  let privateVar = "hidden";
})();

🔟 Modules (import/export) 
ES6 modules for code organization and dependency management.

// math.js
export const add = (a, b) => a + b;
export default function multiply(a, b) { return a * b; }

// main.js
import multiply, { add } from './math.js';
console.log(add(2, 3)); // 5

💡 Practice these in a Node.js REPL or browser console to see how they interact.

💬 Tap ❤️ if you're learning something new!

Computer science A-Level exam papers

https://www.physicsandmathstutor.com/past-papers/a-level-computer-science/caie-paper-1/

Nothing goes smoothly forever. If it is, something is wrong..