👋 Welcome to Learning Log

This is my personal space to document and share my journey as a software developer and as a person growing in life, thought, and faith.

Here, I’ll share:

• Learning progress — currently focused on full-stack web development(typescript) and sometimes Flutter. After a year focused on DSA at A2SV, I’m now fully focused on learning and building real-world products.
• Projects & experiments — small builds, exercises, and hands-on explorations.
• Mistakes & lessons — from coding, learning, and life.
• EUREKA moments (aha moments) — insights that suddenly click while learning dev, life, and belief.
• Thoughts & questions — on software, belief, philosophy, science, and what truly matters.
• Ideas & discussions — exploring decisions, priorities, and how things really work.

If you’re reading this, welcome 😊

React Async Rendering – What Confused Me & What Finally Clicked

I was confused about why async/await works in normal JS, but fails in React client components.
At first it felt inconsistent… but here’s what finally made sense 👇
1️⃣ React client components render synchronouslyWhen React renders, it expects JSX immediately.If a component is async, it returns a Promise, not JSX — and React can’t handle that.
That’s why await directly inside a client component breaks things.
2️⃣ Then why does useEffect work?Because useEffect runs after the render.React renders the UI first, then async work happens later — no blocking.
3️⃣ Why async works in Server ComponentsServer components run on the server.They can await, and React sends HTML only after data is ready.
4️⃣ Where Suspense fits inReact does support async UI — but only when React controls it.Suspense pauses part of the UI, not the whole render.
Final understanding:
Async is not the problem Async during client render is. It’s only allowed when React manages it (Server Components or Suspense).

Reading data → Server Components
Writing data (mutations) → Server Actions
Complex client state → Client Components
Public APIs → API Routes (still valid)

Today I learned 👇

redirect() runs on the server
It stops rendering the current page
Sends a redirect (3xx) to the browser
Browser requests the new URL
Current component is never rendered → React unmounts it

⚠️ When used in a Server Action:

await expects a normal response
redirect() interrupts it
Promise is treated as rejected
catch runs even if server succeeded

Lesson:
❌ Don’t use redirect() in Server Actions awaited by Client Components
✅ Let the client handle navigation

💡 Difference between .then() and async/await

1️⃣ .then() style (Promise chaining)

something()
  .then(result => {
    return otherThing(result);
  })
  .then(final => {
    console.log(final);
  })
  .catch(err => {
    console.error(err);
  });

2️⃣ async/await style (looks synchronous)

try {
  const result = await something();
  const final = await otherThing(result);
  console.log(final);
} catch (err) {
  console.error(err);
}

💡 Async functions and Promises in JS



Any function declared with async automatically returns a Promise, even if you don’t return one explicitly.


Example:

async function foo() {
  console.log(5);
  return 42;
}

const res = foo();
console.log(res); // Promise { 42 }

✅ Conceptually, this is like the engine doing:

function foo() {
  return new Promise((resolve, reject) => {
    try {
      console.log(5);
      resolve(42);  // your returned value
    } catch (err) {
      reject(err);   // if function throws
    }
  });
}

return value → becomes resolve(value)


Throwing an error → becomes reject(error)


So async = syntactic sugar over Promises.
await just pauses execution until that Promise settles.

Original async/await code:

async function getData() {
  const response = await fetch("https://api.example.com");
  const data = await response.json();
  console.log(data);
  console.log("After fetch inside async");
}

getData();

Equivalent manual promise wrapping of the async function body

function getData() {
  // Manually wrap the whole function body in a Promise
  return new Promise((resolve, reject) => {
    // Start fetch (already returns a Promise)
    fetch("https://api.example.com")
      .then(response => {
        // Wait for response.json() (also returns a Promise)
        return response.json();
      })
      .then(data => {
        // This is everything after the await in the original async function
        console.log(data);
        console.log("After fetch inside async");
        resolve(); // resolves the outer promise when the function finishes
      })
      .catch(err => {
        reject(err); // reject the outer promise if any inner promise fails
      });
  });
}

// Calling it
getData().then(() => {
  console.log("getData() finished");
});

✅ What this shows
Outer Promise → wraps the entire async function body (what async function automatically does)
Inner Promises → fetch() and response.json()
await → corresponds to .then() chaining internally
resolve() → happens when the function completes
reject() → propagates any errors


async function getData() {
const response = await fetch(); <==> fetch().then(...)
const data = await response.json(); <==> response.json().then(...)
console.log(data); <==> runs in the last then
}

TypeScript protects you at compile time, but runtime data must be validated manually if you want to be safe

I was today years old when I realized VS Code is basically a browser
It’s a client that sends our code (what we type) to a Language Server using the Language Server Protocol (LSP)
like a mini internet inside my PC

The Language Server (e.g. TypeScript server) reads that code, analyzes it (types, errors, hints, autocomplete…),
and sends results back all locally, no internet involved

It’s literally a client-server architecture without network just process-to-process chat happening inside your machine

VS Code shows the squiggly lines, errors, and smart suggestions instantly
all thanks to that invisible “local server” running in the background

That’s what we mean by compile time in TypeScript this whole path is how your code gets checked before actually running.
TypeScript won’t even let it execute if there’s a type mismatch or syntax error,
because it’s constantly talking to the TypeScript server to validate everything in real time.

And imagine… this happens every time you press a key.
Every keystroke triggers this tiny local “client-server” check inside your machine 🤯

design thinking. by David kalle,
a friend of Steve jobs.

https://youtu.be/GYkb6vfKMI4?si=N5RFwbJGsWyq7r-Z

UX

Test your eye for design details with this fun game!


https://cantunsee.space/

JavaScript Async Flow & Promises

JavaScript is single-threaded, meaning only one thing executes at a time on the call stack. When we call an async function like fetch(), the function itself runs briefly on the call stack, immediately returning a pending Promise, so the synchronous code continues without waiting. The actual async work (e.g., network request, timer) happens outside the JS thread in the browser or Node environment.

Once the async task completes, the engine marks the Promise as fulfilled or rejected. Any .then() or .catch() callbacks attached to the promise are pushed into the microtask queue, not executed immediately. The event loop continuously checks: when the call stack is empty, it drains the microtask queue, moving each callback back onto the call stack for execution.

In short, Promises + event loop + microtasks allow JS to handle async operations without blocking the main thread, ensuring smooth execution. Immediate promises like Promise.resolve(10) simulate this behavior instantly, while real-world async tasks like fetch() take time but follow the same flow.

Dev tool in Amharic. 😕

I came across a post and its comments that really made me think.... [The post] and this tech nerd  post too [the post] .......

For a long time, I’ve been hesitating to make this channel public.

But now I understand something simple:
"If you wait until you feel confident, you’ll never start anything."

Let’s grow together😊 . If u are senior kindly request to guide me and review my work through the progress too.
https://t.me/code4Lifee

chatgpt with web search feature Vs without.

Genz 🤝 TypeScript