🔵 عنوان مقاله
GopherCon Korea 2025

🟢 خلاصه مقاله:
**GopherCon Korea 2025 حدود یک ماه دیگر، در تاریخ ۹ نوامبر برگزار می‌شود. این رویداد جامعه‌محور برای توسعه‌دهندگان Go (Golang) فرصتی مناسب است تا به‌روزترین روندها را دنبال کنند، تجربه‌های عملی را به اشتراک بگذارند و شبکه‌سازی مؤثری داشته باشند. معمولاً نشست‌ها به موضوعاتی مانند مفاهیم زبان و کارایی، الگوهای هم‌زمانی، توسعه cloud-native و microservices، ابزارها و observability و مطالعات موردی در مقیاس تولید می‌پردازد. اگر قصد حضور دارید، اکنون زمان خوبی برای ثبت‌نام و برنامه‌ریزی سفر است و پیگیری کانال‌های رسمی برای جزئیات برنامه و مکان توصیه می‌شود.

#GopherConKorea #GopherCon #Golang #Go #TechConference #Developers #Korea #SoftwareEngineering

🟣لینک مقاله:
https://golangweekly.com/link/175357/web

➖➖➖➖➖➖➖➖
👑 @gopher_academy

🔵 عنوان مقاله
Constraining LLMs with Structured Output in Python and Go

🟢 خلاصه مقاله:
**این مجموعه به روش‌های عملی برای واداشتن LLMها به تولید خروجی ساخت‌یافته می‌پردازد تا ادغام در سیستم‌های تولیدی قابل اعتماد، قابل اعتبارسنجی و قابل آزمون باشد. در Python با تعریف شِماهای سازگار با JSON و اتصال خروجی مدل به انواع مشخص، و در Go با استفاده از structهای نوع‌دار، struct tagها، و خطاهای صریح، خطر خروجی متنی آزاد و شکننده کاهش می‌یابد.

همچنین یک ویدئو از Rost Glukhov ساخت یک عامل کدنویس در Go را از ابتدا نشان می‌دهد؛ از طراحی پرامپت و برنامه‌ریزی تا اجرای ابزار و حلقه بازخورد. در بخش کارهای زمان‌بندی انبوه، مقاله Bill Kennedy توضیح می‌دهد چگونه Timing Wheels بدون پیمایش O(n) می‌توانند میلیون‌ها کلید را منقضی کنند—الگویی مفید برای زمان‌بندی‌کننده‌ها، کش‌ها و محدودکننده‌های نرخ در Go. برای درک عمیق‌تر همروندی، نوشتار Ankur Anand رفتار و انتخاب‌های درست پیرامون primitives بسته sync مانند Mutex، RWMutex، WaitGroup و Cond را تشریح می‌کند. در پایان، مطلبی از Matheus Mina این مجموعه را کامل می‌کند. حاصل کار، جعبه‌ابزاری عملی برای ساخت عامل‌ها و سرویس‌های پربازده در Python و Go است.

#Go #Python #LLM #StructuredOutput #TimingWheels #Concurrency #Golang #Agents

🟣لینک مقاله:
https://golangweekly.com/link/175364/web

➖➖➖➖➖➖➖➖
👑 @gopher_academy

♨️ اپل زیر تیغ شکایت تازه به خاطر دزدی ادبی از دانشمندا! 😳

▪️دو استاد عصب‌پژوه از دانشگاه SUNY Downstate نیویورک از اپل شکایت کردن، چون می‌گن این شرکت کتاب‌ها و آثار علمی اونا رو بدون اجازه برای آموزش هوش مصنوعی خودش یعنی Apple Intelligence استفاده کرده!

📘 آثار مورد بحث هم دوتا کتاب معروف هستن:

▫️Champions of Illusion
▫️Sleights of Mind

▪️به گفته شاکیا، اپل این کتاب‌ها رو از سایت‌های موسوم به «کتابخونه‌های سایه‌ای» (Shadow Libraries) با نرم‌افزارهای خزنده (Web Crawlers) جمع کرده و داده‌ی آموزشی مدل‌هاش کرده

One of the best practical YouTube Channels to learn DevOps Tools and Skills.
یکی از بهترین کانال‌هایی که بصورت عملی ابزارهای DevOps رو بصورت ملموس و خیلی کوتاه و مختصر و مفید توضیح و آموزش میده

#DevOps #Terraform #Helm #Kubernetes #AWS #GCP #Azure

https://www.youtube.com/@AntonPutra

🔵 عنوان مقاله
Lo v1.52.0: A Lodash-Style Library for Go 1.18+

🟢 خلاصه مقاله:
** Lo v1.52.0 یک کتابخانه سبک Lodash برای Go 1.18+ است که مجموعه‌ای از توابع کمکیِ آماده برای کار با slice و map و سایر کالکشن‌ها را فراهم می‌کند. با تکیه بر generics در Go، این ابزار توابعی مانند Map، Filter، Reduce، GroupBy، Chunk، و عملیات مجموعه‌ای مثل Union و Intersect را به‌صورت type-safe و بدون نیاز به reflection ارائه می‌دهد. هدف آن کاهش کد زائد، ساده‌سازی پردازش داده‌ها، و افزایش خوانایی است؛ به‌طوری‌که بتوان به‌جای حلقه‌های تودرتو، زنجیره‌ای از توابع قابل‌خواندن و کارا نوشت. نسخه v1.52.0 این رویکرد را برای کاربران Go 1.18+ تثبیت کرده و تجربه‌ای روان و کارآمد برای تبدیل و مدیریت کالکشن‌ها فراهم می‌کند.

#Go #Golang #Lo #Lodash #Generics #Go18 #Libraries #FunctionalProgramming

🟣لینک مقاله:
https://golangweekly.com/link/175369/web

➖➖➖➖➖➖➖➖
👑 @gopher_academy

🔵 عنوان مقاله
why, as a gopher, he's excited about Gleam

🟢 خلاصه مقاله:
برای یک توسعه‌دهنده Go، جذابیت Gleam در این است که سادگی و شفافیت Go را با یک سیستم نوع‌دهی قوی و ویژگی‌هایی مثل نبود null، الگو‌تطبیق و داده‌های جبری ترکیب می‌کند، و در عین حال روی Erlang VM (BEAM) اجرا می‌شود تا مزیت فرآیندهای سبک، ارسال پیام و درخت‌های نظارت را به‌صورت ذاتی فراهم کند. این ترکیب برای سرویس‌های همزمان، توزیع‌شده و IO-bound که به تحمل‌پذیری خطا و پایداری نیاز دارند بسیار مناسب است. Gleam با اکوسیستم Erlang/Elixir به‌خوبی سازگار است، به Erlang کامپایل می‌شود و حتی خروجی JavaScript هم دارد، بنابراین می‌توان از کتابخانه‌های جاافتاده استفاده کرد بدون چشم‌پوشی از ایمنی نوعی. ابزارهای توسعه بالغ و کاربرپسند هستند، اما اکوسیستم هنوز جوان است و برای کارهای CPU-bound یا باینری‌های تک‌فایلی سریع، Go همچنان برتری دارد. جمع‌بندی: Go را برای محاسبات سنگین و ابزارها نگه دارید و Gleam را برای سرویس‌های مقاوم و همزمان روی BEAM در نظر بگیرید.

#Gleam #Go #ErlangVM #BEAM #Concurrency #FaultTolerance #FunctionalProgramming #Elixir

🟣لینک مقاله:
https://golangweekly.com/link/175355/web

➖➖➖➖➖➖➖➖
👑 @gopher_academy

شرکت اوبر یکی شرکت های بزرگه که از زبان گو استفاده می‌کنه، اینجا می‌تونید کد استایلی که با زبان گو می‌زنن رو ببینید نسخه ترجمه شده به فارسی هم داره ولی یکم دیر تر از نسخه اصلیش آپدیت می‌شه
https://github.com/uber-go/guide

<Nimo/>

🔵 عنوان مقاله
that runs on the Erlang VM.

🟢 خلاصه مقاله:
این مقاله در Golang Weekly به معرفی فناوری‌ای می‌پردازد که روی Erlang VM اجرا می‌شود و برای برنامه‌نویسان Go اهمیت دارد. مقاله مزیت‌های کلیدی Erlang VM مانند فرایندهای سبک، پیام‌رسانی و تحمل خطا را توضیح می‌دهد و آن‌ها را با مدل goroutine و channel در Go مقایسه می‌کند. سپس پیامدهای عملی این تفاوت‌ها را بر مقیاس‌پذیری، تاب‌آوری و تأخیر در سیستم‌های توزیع‌شده، همراه با ملاحظات استقرار، هم‌پیوندی و مشاهده‌پذیری، مرور می‌کند. جمع‌بندی مقاله این است که استفاده از فناوری‌های مبتنی بر Erlang VM می‌تواند برای تیم‌های Go که به دسترس‌پذیری بالا نیاز دارند، مکملی ارزشمند باشد؛ انتخاب نهایی به نیازهای مسئله و تجربه تیم وابسته است.

#ErlangVM #Go #GolangWeekly #Concurrency #DistributedSystems #FaultTolerance #Scalability

🟣لینک مقاله:
https://golangweekly.com/link/175356/web

➖➖➖➖➖➖➖➖
👑 @gopher_academy

می‌دونستید می‌تونید 0 های آی‌پی رو ننویسید و کار کنه؟؟؟

خب حالا سیستم از کجا میفهمه‌ چطوری؟

بر اساس این که شما چند بخش رو نوشتید کار می‌کنه:

a.b.c.d -> یه آیپی معمولی
a.b.c -> a.b.0.c
a.b -> a.0.0.b
a -> 0.0.0.a

پس وقتی بنویسید 10.22.2 میشه 10.22.0.2
یا اگر بنویسید 127.1 میشه 127.0.0.1
یعنی سیستم قسمت‌های جا افتاده رو از چپ با صفر پر می‌کنه.

⚙️ مکانیزم گسترش ظرفیت (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