started with a win 💙

#fcb

Japanese version of scare tactics lmao 💀

this got me lmao 😅

happy Sunday anyways 🙌

without a doubt 💯

Understanding the Go Runtime: A Deep Dive

So, the Go runtime is like the brains behind the Go programming language. It handles all the behind-the-scenes stuff, making sure everything runs smoothly, from managing memory to keeping all those little goroutines in line.

Let's break it down:

1. Goroutines: Think of them as mini-threads, super lightweight and totally awesome for concurrency. The runtime keeps track of all these goroutines and makes sure they all get their fair share of CPU time.

2. The Scheduler: It's like the air traffic controller of the Go runtime. It manages all those goroutines, deciding who gets to run and when, using a fancy technique called 'work-stealing'. This way, no goroutine gets stuck waiting around, and things keep moving along.

3. Garbage Collection: The clean-up crew! The Go runtime automatically handles memory, identifying and getting rid of memory that's no longer needed. It does this without slowing things down, using a technique called 'concurrent mark-and-sweep'. You don't have to worry about memory leaks – the runtime takes care of all the dirty work.

Use Cases

package main

import (
 "fmt"
 "time"
)

func sayHello() {
 for i := 0; i < 5; i++ {
  fmt.Println("Hello from goroutine!")
  time.Sleep(100 * time.Millisecond)
 }
}

func main() {
 go sayHello() // Let's kick off a new goroutine

 // Keep doing our thing in the main goroutine 
 for i := 0; i < 5; i++ {
  fmt.Println("Hello from main!")
  time.Sleep(150 * time.Millisecond)
 }
}

In this example, sayHello is running concurrently with main. The runtime is managing the whole shebang, making sure both functions get their chance to run.

The Scheduler in Action

The Go scheduler uses a cool system called Proportional Fair Scheduling (PFS), giving each goroutine a fair shot at the CPU. It's always checking in on the goroutines, making sure everything is running smoothly and no one is getting stuck.

It also uses a concept called M, P, and G:

- M (Machine): These are the actual OS threads running your program.
- P (Processor): Think of them as virtual processors, managed by the scheduler.
- G (Goroutine): The mini-threads we talked about.

When you create a goroutine, it gets assigned to a processor, which manages its execution. Sometimes, a goroutine might need to pause, maybe to wait for some input or data. The runtime handles this gracefully, letting other goroutines take over while the paused one chills out.

Let's Wrap It Up

The Go runtime is a total powerhouse. It keeps your Go code running smoothly and efficiently, allowing you to build awesome concurrent applications without getting bogged down in low-level details.

#TakeAByte #GoRuntime #golang
@Mi_Ra_Ch

I take calculated risks but i am bad at math 🙂

tempting tbh 😅

so i wanted to import markdown files in my .tsx file in vite project. well to import .md files in a vite project, you need an extra plugin to configure it in vite.config.ts file. but most plugins don't work as expected. so i got a way around it. i've also created a Gist for it if you wanna check. first in your vite-env.d.ts file, put the following line to let typescript treat .md files as a module.

declare module '*.md';

then in your vite.config.ts file put the following code to create a custom plugin which loads .md files and gets the raw content of the .md file

import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';

// https://vitejs.dev/config/
export default defineConfig({
  plugins: [
    react(),
    // Custom plugin to load markdown files
    {
      name: 'markdown-loader',
      transform(code, id) {
        if (id.slice(-3) === '.md') {
          // For .md files, get the raw content
          return `export default ${JSON.stringify(code)};`;
        }
      },
    },
  ],
});

there you go, you can now import markdown file in your project 🙂

#tips #vite #ts
@Mi_Ra_Ch

32-bit vs 64-bit: Technical Depths of Computer Architecture

aight homies, lemme walk u through one of the interesting concept i liked while i was reading sth lately (not a hardware geek tho lol)

32-bit vs. 64-bit

The fundamental difference between 32-bit and 64-bit architectures lies in their address space and data representation.

Address Space: This refers to the range of memory addresses a CPU can directly access. In a 32-bit system, the address space is limited to 2^32 (4,294,967,296) unique addresses, while a 64-bit system boasts an address space of 2^64 (approximately 18 quintillion). This dramatic increase in address space allows 64-bit systems to directly access significantly larger amounts of memory, leading to improved performance for memory-intensive applications.

Data Representation: The size of a data word (the unit of data processed by the CPU) also differs. A 32-bit system uses 32-bit registers and instructions, while a 64-bit system employs 64-bit registers and instructions. This translates to the ability to process larger amounts of data concurrently, enhancing computational power.

Alternative Architectures

While 32-bit and 64-bit are prevalent, other architectures deserve recognition for their unique strengths:

ARM (Advanced RISC Machine): Renowned for its energy efficiency, ARM architecture is optimized for mobile devices and embedded systems. Its focus on instruction set simplicity and efficient data handling makes it suitable for battery-powered devices and applications where low power consumption is critical.

RISC-V (Reduced Instruction Set Computing - Version 5): This open-source, customizable architecture has gained traction in recent years. Its modular design allows for flexibility in implementation, enabling tailored configurations to meet specific performance and resource constraints. It's poised to revolutionize the landscape of embedded systems and custom hardware development.

Performance Implications and Compatibility Considerations

The shift from 32-bit to 64-bit has had significant performance implications:

Increased Memory Capacity: 64-bit systems can handle large datasets and complex applications that would strain 32-bit systems due to memory limitations.
Enhanced Computational Power: 64-bit processors can process more data simultaneously, leading to faster execution times for computationally intensive tasks.
Compatibility Issues: Software specifically designed for 32-bit systems may not run seamlessly on 64-bit platforms, necessitating compatibility considerations for application development and deployment.

Lets wrap it up

32-bit: Good for basic stuff, but limited in memory.
64-bit: The go-to option for modern computers, offering more memory and performance.
ARM: Efficient for mobile devices and low power usage.
RISC-V: Open source and customizable, the new kid on the block lol

understanding these architectural nuances is crucial for making informed decisions about hardware selection, software development, and optimization strategies to maximize performance and efficiency.

#TakeAByte #ComputerArchitecture #32bitvs64bit #ARM #RISCV
@Mi_Ra_Ch

lmao i genuinely laughed out loud 😂

sup homies :)

literally pulling an all-nighter for the straight 29 days 🙂 just a peaceful life 🤗😭

noticed a bug on their official site, and was about to send a pr. thank you tele 🙌

10 things you (probably) don't know about Go - a talk from 2012 but still some of the concepts apply with some tweak

#golang

peeps making a plain React app without next.js, use react-helmet if you aren't using it already. it will help a lot for a SEO and link preview across social medias. use this guide to get started.

#reactjs

wish y'all a happy Saturday ✌️

hmm... did you guys know the fact that if you have something to wear, something to eat, a rooftop above your head, can read and understand what i typed, and some money you hold in your pocket, you're among 20% of the wealthiest people on earth. so many blessings, but we insist on being grateful most of the time