had a human-contact outside of my family members today. such a milestone 😊🙌

Go is a bit slower than compiled languages like C mostly due to its automated memory management also known as the "Go runtime". oftentimes this is for memory safety and simpler syntax.

#golang

I'm hoping a lot from Barca and Arsenal this year. both got a match today

fyi i've been a diehard fan of Barcelona since i was 6 or 7 😭

lmao so true

facts 💯

Jesus Christ!

i can only imagine how many different cases are not still known and many parents have been mistreated in front of Justice.

guys, please sign this and share

https://chng.it/5b9YpzX6CQ

this part of my life is called growing

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