با این ابزار دسکتاپ می‌تونید اپلیکیشن های ری‌اکت و ری‌اکت نیتیوی رو inspect کنید و حتی تغییر بدید

از قسمت ریلیز ها هم ‌تونید نسخه ویندوز و مک و لینوکسش رو دانلود کنید :

github.com/infinitered/reactotron

@Linuxor

می‌دونستین Sqlite یه نسخه توزیع شده داره که بهش می‌گن Rqlite باهاش می‌تونید توزیع شده SQL رو اجرا کنید مثلا اگه یه گره دیتاش خراب شد سیستم در دسترس باشه به درد IoT یا اینترنت اشیاء می‌خوره (مثلا یه عالمه سنسور دارید می‌خواید اگه یکیشون مشکل پیدا کرد کل سیستم خراب نشه و حتی اطلاعاتشون هم خودکار باهم سینک بشه)


@Linuxor

جالبه، یه مدت هر سایتی رو باز می‌کردی نوشته بودن که RAG is Dead و می‌گفتن که باید بریم به سمت mcp ولی الان یه چرخش خیلی سنگین می‌بینم از mcp به سمت RAG.
آیا من اشتباه می‌کنم و نتایجی که می‌بینم سوگیری دارن؟

جالبه بدونید درسته اپ های بزرگ مثل اینستاگرام از تکنولوژی‌هایی مثل پایتون و جنگو استفاده میکنن
ولی نه اون پایتون و جنگویی که ما میشناسیم
میان یه فورک از اون زبان یا فریم ورک رو متناسب با نیازمندی هاشون درست میکنن و خیلی چیزهارو تغییر میدن
مثلا نسخه پایتونی که اینستاگرام استفاده میکنه استاتیک تایپه Jit هست gil نداره وحشتناک سریعه و .... کلی چیز میز های مختلف که برای نیازهای اینستاگرام اضافه شده :)

ماشین مخصوص برنامه نویس ها؛ دارای میز کار

@Linuxor

عجیب ترین چیزی بود که می‌تونستم ببینم.



خدا عاقبت مارو بخیر کنه.


@SohrabContents

احتمالا با Lorem Ipsum آشنا هستید. یک متن ساختگی به خاطر نسبتا طولانی بودنش و همچنین دربر گرفتن تعداد زیادی از حروف الفبای لاتین (و بعدها ترجمه‌هاش به زبان‌های دیگر) خیلی در نمونه‌های گرافیکی، طراحی وبسایت و ... به کار می‌ره.
حالا این هم یک وبسایت با کارایی مشابه ولی در حوزه تصویره:

https://picsum.photos/

اگر برای پر کردن صفحاتی که به عنوان نمونه طراحی می‌کنید، نیازمند تصویر هستید از دستش ندید.

@haghiri75_blog

یک ترد جالب تو ردیت
از اینجور آدما فراری باشید :)
کامنت خیلی خوب بود.. resume driven development 😂


@PyBackendHub

یک ترد جالب تو ردیت
از اینجور آدما فراری باشید :)
کامنت خیلی خوب بود.. resume driven development 😂

@PyBackendHub

من مستقیما بچه هاش رو نمی شناسم ولی شاید براتون جالب باشه. کد تخفیف jadi رو هم تست کنید شاید به درد خورد (:

🔶 ویدئو لحظه شروع آتش‌سوزی در مرکز داده ملی کره جنوبی (NIRS – دائجون) | فاجعه فناوری ۲۶ سپتامبر ۲۰۲۵

#خبر

@TheRaymondDev

مولانا | دیوان شمس | رباعیات | رباعی شمارهٔ ۱۴۸۴

سرمست شدم در هوس سرمستان
از دست شدم در ظفر آن دستان
بیزار شدم ز عقل و دیوانه شدم
تا درکشدم عشق به بیمارستان

#مولانا | گنجور
📍@iipoem

اگه سایت وردپرسی دارید این مسیرو چک کنید:

/wp-json/wp/v2/users

@TheRaymondDev

ایجاد dark mode فقط با css بدون یک خط js

codepen:
https://codepen.io/ditheringidiot/pen/JjbzNMz

@DevTwitter | <Hesam Valizadeh/>

⚙️ مکانیزم گسترش ظرفیت (cap) در Slice

وقتی یه slice در Go پر می‌شه و شما با append() عنصر جدیدی بهش اضافه می‌کنی،
Go متوجه می‌شه که ظرفیت (capacity) فعلی کافـی نیست و باید حافظه‌ی بیشتری اختصاص بده.
به این فرآیند می‌گن slice growth یا reallocation.


🧠 مرحله‌به‌مرحله چه اتفاقی می‌افته؟

فرض کن داریم:

s := make([]int, 3, 3)

الان:

* len(s) = 3
* cap(s) = 3

حالا اگر بنویسی:

s = append(s, 10)

Go متوجه می‌شه که ظرفیت فعلی (۳) پر شده.
در نتیجه:

1. یه بافر جدید در حافظه ایجاد می‌کنه (یه آرایه‌ی جدید با ظرفیت بزرگ‌تر)
2. تمام عناصر قبلی (10, 20, 30) رو به آرایه‌ی جدید کپی می‌کنه
3. عنصر جدید رو اضافه می‌کنه
4. و یه slice جدید که به آرایه‌ی جدید اشاره می‌کنه، برمی‌گردونه


📈 حالا ظرفیت چقدر زیاد می‌شه؟

Go از یه الگوریتم رشد پویا (dynamic growth algorithm) استفاده می‌کنه.
الگو به‌صورت تقریبی اینطوریه:

✅ تا ظرفیت‌های کوچک:

وقتی cap کوچیکه (مثلاً زیر 1024)،
ظرفیت معمولاً ۲ برابر می‌شه.

مثلاً:

cap: 1 → 2 → 4 → 8 → 16 → 32 → ...

✅ وقتی ظرفیت بزرگ شد (≥ 1024):

Go رشد رو آهسته‌تر می‌کنه تا حافظه هدر نره.
تقریباً ظرفیت جدید ≈ ظرفیت فعلی × 1.25 (یعنی حدود 25٪ افزایش).

مثلاً:

cap: 1024 → 1280 → 1600 → 2000 → ...

🔬 مکانیزم دقیق در سورس‌کد Go

در پیاده‌سازی داخلی زبان Go (در runtime/slice.go)، تابعی وجود داره به نام:

growslice(et *_type, old slice, cap int) slice

این تابع دقیقاً تصمیم می‌گیره:

* ظرفیت جدید چقدر باشه
* حافظه جدید کجا اختصاص پیدا کنه
* چطور داده‌های قبلی کپی بشن

📌 بخشی از منطق اون (به‌صورت ساده‌شده) اینطوریه:

newcap := old.cap
doublecap := newcap + newcap
if cap > doublecap {
    newcap = cap
} else {
    if old.cap < 1024 {
        newcap = doublecap
    } else {
        for newcap < cap {
            newcap += newcap / 4 // رشد 25 درصدی
        }
    }
}

---

🧩 نتیجه:

* append() در واقع یه slice جدید می‌سازه با آرایه‌ی بزرگ‌تر.
* cap به شکل نمایی (expontential) رشد می‌کنه تا کارایی حفظ بشه.
* حافظه‌ی قبلی ممکنه توسط garbage collector آزاد بشه اگه دیگه بهش اشاره‌ای نباشه.

---

📊 مثال برای درک تغییر ظرفیت:

s := []int{}
for i := 0; i < 10; i++ {
    s = append(s, i)
    fmt.Printf("len=%d cap=%d\n", len(s), cap(s))
}

📤 خروجی معمولی:

len=1 cap=1
len=2 cap=2
len=3 cap=4
len=4 cap=4
len=5 cap=8
len=6 cap=8
len=7 cap=8
len=8 cap=8
len=9 cap=16
len=10 cap=16

می‌بینی چطوری ظرفیت به شکل ۲ برابر رشد می‌کنه.


➖➖➖➖➖➖➖➖
👑 @gopher_academy

بریم دقیق‌تر سراغ الگوریتم رشد پویا (dynamic growth algorithm) توی Go — چون این یکی از طراحی‌های خیلی هوشمندانهٔ Go برای مدیریت حافظه و performance هست.


⚙️ تعریف ساده:

وقتی یه slice داری و با append() داده‌ی جدید بهش اضافه می‌کنی،
اگر ظرفیت (`cap`) پر شده باشه**، Go باید تصمیم بگیره **چقدر حافظه‌ی جدید رزرو کنه.

الگوریتم رشد پویا دقیقاً وظیفه‌اش همینه:

> چطور ظرفیت جدید (newCap) محاسبه بشه، تا نه حافظه زیاد هدر بره، نه append‌ها کند بشن.



🧩 هدف الگوریتم رشد پویا:

Go می‌خواد بین دو چیز تعادل ایجاد کنه:

| هدف | توضیح |
| 🏎 سرعت بالا | با رشد نمایی (مثل ×2) تعداد دفعات تخصیص حافظه کم می‌شه.
| 💾 مصرف بهینه حافظه | با رشد تدریجی (مثل ×1.25) در ظرفیت‌های بالا از هدر رفت RAM جلوگیری می‌شه.



🔍 منطق داخلی (بر اساس runtime/slice.go)

الگوریتم در تابع داخلی Go به نام growslice() پیاده‌سازی شده.
خلاصه‌اش به این صورته:

func growslice(et *_type, old slice, cap int) slice {
    newcap := old.cap
    doublecap := newcap + newcap  // ظرفیت دو برابر

    if cap > doublecap {
        newcap = cap
    } else {
        if old.cap < 1024 {
            newcap = doublecap       // برای ظرفیت‌های کوچک: رشد ۲ برابری
        } else {
            // برای ظرفیت‌های بزرگ‌تر: رشد تدریجی (حدود 25٪)
            for newcap < cap {
                newcap += newcap / 4 // افزایش 25%
            }
        }
    }
    // در ادامه حافظه جدید اختصاص داده میشه و داده‌های قبلی کپی می‌شن
}

📈 نتیجه‌ی این منطق

| بازهٔ ظرفیت فعلی | نحوهٔ رشد | مثال
| < 1024 | رشد نمایی (۲ برابر) | 64 → 128 → 256 → 512 → 1024
| ≥ 1024 | رشد خطی-تدریجی (۱.۲۵ برابر) | 1024 → 1280 → 1600 → 2000 → 2500



🧠 چرا این الگوریتم هوشمنده؟

1. در ظرفیت‌های کوچک:
رشد دو برابری باعث می‌شه appendها سریع‌تر باشن (کمتر نیاز به کپی داده داریم).
یعنی append تقریباً در زمان amortized O(1) انجام می‌شه.

2. در ظرفیت‌های بزرگ:
رشد کمتر باعث صرفه‌جویی در حافظه می‌شه چون کپی‌کردن چند مگابایت داده هزینه‌بره.

3. در مجموع:
الگوریتم به شکل پویا بسته به اندازهٔ فعلی slice تصمیم می‌گیره چطور رفتار کنه → بهینه برای performance و memory.



📊 مثال واقعی از رشد پویا:

s := make([]int, 0)
for i := 0; i < 2000; i++ {
    s = append(s, i)
    if i%200 == 0 {
        fmt.Printf("len=%d, cap=%d\n", len(s), cap(s))
    }
}

📤 خروجی تقریبی:

len=0, cap=0
len=200, cap=256
len=400, cap=512
len=600, cap=1024
len=800, cap=1024
len=1000, cap=1280
len=1200, cap=1600
len=1400, cap=2000
len=1600, cap=2000
len=1800, cap=2500
len=2000, cap=2500

می‌بینی که تا 1024 ظرفیت دو برابر می‌شه، بعدش رشدش 25٪ می‌ره بالا. 🔥



📚 جمع‌بندی ساده

| ویژگی | توضیح
| نام الگوریتم | Dynamic Growth Algorithm
| هدف | افزایش ظرفیت slice به‌شکل خودکار و بهینه
| تا 1024 | رشد دو برابری (exponential)
| بیش از 1024 | رشد حدود 25٪ در هر بار (incremental)
| مزیت | سرعت بالا + صرفه‌جویی در حافظه
| محل پیاده‌سازی | runtime/slice.go → growslice()


➖➖➖➖➖➖➖➖
👑 @gopher_academy