This media is not supported in your browser
VIEW IN TELEGRAM
Japanese version of scare tactics lmao 💀
🤣6
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
In this example,
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
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
⚡4
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.
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
there you go, you can now import markdown file in your project 🙂
#tips #vite #ts
@Mi_Ra_Ch
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
🔥4
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
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
🔥5
literally pulling an all-nighter for the straight 29 days 🙂 just a peaceful life 🤗😭
🤯3
10 things you (probably) don't know about Go - a talk from 2012 but still some of the concepts apply with some tweak
#golang
#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
#reactjs
👍1