🔵 عنوان مقاله
qjs: Run JavaScript in Go

🟢 خلاصه مقاله:
qjs یک روش تازه برای اجرای JavaScript داخل اپ‌های Go است که بدون نیاز به Cgo کار می‌کند. به‌جای اتصال به یک کتابخانه بومی، نسخه فورک‌شده‌ای از QuickJS را به WebAssembly کامپایل کرده و آن را زیر Wazero اجرا می‌کند. این رویکرد کل زنجیره را در محیط خالص Go نگه می‌دارد و فرایند بیلد، استاتیک‌سازی و کراس‌کامپایل را ساده‌تر می‌کند. مزیت دیگر، ایزوله‌سازی و سندباکس طبیعی ناشی از WebAssembly است. هرچند احتمالاً نسبت به اتصال بومی اندکی سربار دارد، اما برای سناریوهایی مثل اسکریپت‌نویسی، افزونه‌ها و اجرای امن منطق کاربر، توازن خوبی بین سادگی، پرتابل‌بودن و امنیت ارائه می‌دهد.

#Go #JavaScript #WebAssembly #Wazero #QuickJS #Cgo #GoLang #Embedding

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

➖➖➖➖➖➖➖➖
👑 @gopher_academy

🔵 عنوان مقاله
Terminating Elegantly: A Guide to Graceful Shutdowns

🟢 خلاصه مقاله:
ترک شایسته در سرویس‌ها یعنی برنامه بتواند با دریافت SIGTERM، بدون از دست دادن داده یا خراب کردن وضعیت، درخواست‌های جاری را تمام کند و منابع را درست آزاد کند. در این ارائه، Alex Pliutau با تمرکز بر Go در Kubernetes، چرخه کامل خاتمه را توضیح می‌دهد: از دریافت سیگنال و قطع‌کردن ترافیک تا ضرب‌الاجل SIGKILL.

نکته‌های کلیدی شامل این‌هاست: استفاده از signal.NotifyContext و context برای لغو هماهنگ، مدیریت goroutineها با sync.WaitGroup، فراخوانی http.Server.Shutdown یا معادل gRPC برای تخلیه امن اتصال‌ها، و توقف گرفتن کار جدید در Workerها درحالی‌که کارهای درحال اجرا به‌صورت زمان‌دار تمام می‌شوند. در Kubernetes باید readiness زودتر غیرفعال شود تا Pod از مسیر ترافیک خارج شود، از preStop برای تأخیر یا Drain سفارشی کمک بگیرید، و terminationGracePeriodSeconds را درست تنظیم کنید. پایش و آزمون نیز ضروری است: لاگ شروع/پایان Shutdown، سنجه‌هایی مثل تعداد درخواست‌های درحال پردازش و زمان خاتمه، و تست SIGTERM تحت بار. رعایت این الگوهای ساده، خاتمه‌ای قابل اعتماد و بدون اختلال در Go روی Kubernetes فراهم می‌کند.

#Go #Kubernetes #GracefulShutdown #CloudNative #Microservices #DevOps #Reliability #ProductionOps

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

➖➖➖➖➖➖➖➖
👑 @gopher_academy

🔵 عنوان مقاله
Go v1.25.2 and v1.24.8 have been released

🟢 خلاصه مقاله:
به‌روزرسانی‌های Go در نسخه‌های v1.25.2 و v1.24.8 منتشر شده‌اند که مجموعه‌ای از اصلاحات امنیتی را در بسته‌های مختلف ارائه می‌کند. این نسخه‌ها از نوع وصله‌ای و سازگار به عقب هستند و بدون تغییر در رفتار زبان، امنیت و پایداری ابزارها و کتابخانه‌ها را بهبود می‌دهند. توصیه می‌شود هرچه سریع‌تر به آخرین وصله در شاخه فعلی‌تان ارتقا دهید (برای v1.25 به v1.25.2 و برای v1.24 به v1.24.8)، یادداشت‌های انتشار و هر CVE مرتبط را بررسی کنید، باینری‌ها را مجدداً بسازید و ابزارهایی مانند govulncheck را برای شناسایی وابستگی‌های آسیب‌پذیر اجرا کنید.

#Go #Golang #Security #Update #PatchRelease #CVE #DevOps #SoftwareMaintenance

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

➖➖➖➖➖➖➖➖
👑 @gopher_academy

🧱 Heap Management در Go

در Go، مفهوم heap با چیزی که در سیستم‌عامل می‌شناسیم فرق داره.
Go روی memory-mapped segments، یه لایه‌ی مخصوص خودش ساخته به نام mheap 🧠

🔹 mheap مرکز فرماندهی حافظه‌ست:

اختصاص (allocate) اسپن‌های جدید

پاک‌سازی (sweep) اسپن‌های بدون استفاده

مدیریت حافظه‌ی مربوط به goroutine stack‌ها

به بیان ساده، mheap مثل یک مدیر حافظه‌ی مرکزی عمل می‌کنه که کل heap و stackهای goroutine‌ها رو زیر نظر داره.
➖➖➖➖➖➖➖➖
👑 @gopher_academy

⚙️ Span Allocation: mheap.alloc

در فضای عظیم آدرس مجازی، پیدا کردن چند صفحه‌ی آزاد پشت سر هم (contiguous pages) کار ساده‌ای نیست — مخصوصاً وقتی چندین goroutine همزمان در حال تخصیص حافظه‌ان 😵‍💫

در نسخه‌های اولیه‌ی Go، تمام عملیات‌های mheap به‌صورت global sync انجام می‌شدن، یعنی فقط یک goroutine در آنِ واحد می‌تونست حافظه بگیره یا آزاد کنه.
نتیجه؟ 🔻 سرعت کم و افزایش latency در بارهای زیاد.

🧠 اما Go جدید با طراحی جدیدی به نام Scalable Page Allocator این مشکل رو حل کرده:

تقسیم‌بندی allocator برای کاهش قفل‌گذاری (lock contention)

تخصیص هم‌زمان و مستقل در چندین CPU

بهبود چشمگیر throughput در workloadهای سنگین

در واقع، mheap.alloc امروزی طوری طراحی شده که بتونه در محیط‌های بسیار concurrent هم حافظه رو سریع و هوشمند مدیریت کنه 🚀
➖➖➖➖➖➖➖➖
👑 @gopher_academy

📦 Tracking Free Pages

در Go، فضای آدرس مجازی بسیار بزرگه، بنابراین برای مشخص کردن وضعیت هر صفحه (آزاد یا در حال استفاده) از bitmap استفاده می‌شه

در این bitmap:

1 = صفحه در حال استفاده (توسط span)

0 = صفحه آزاد

🔹 هر bitmap شامل ۸ عدد uint64 هست (یعنی ۶۴ بایت) و وضعیت ۵۱۲ صفحه‌ی متوالی رو نگه می‌داره.
🔹 از اون‌جا که هر arena در Go اندازه‌ی ۶۴ مگابایت داره و هر صفحه ۸ کیلوبایت هست، پس در هر arena:

۸۱۹۲ صفحه داریم

۱۶ تا bitmap برای پوشش کل صفحات

در مجموع فقط ۱ کیلوبایت حافظه برای ذخیره‌ی وضعیت کل صفحات لازمه! ⚡️

اما مشکل: پیمایش bitmap برای پیدا کردن صفحات آزاد هنوز کند بود ⏳
برای حل این، Go مفهومی به نام Summary معرفی کرد که سه ویژگی داره:

start → تعداد صفرهای پشت سر هم از ابتدای bitmap

end → تعداد صفرهای پشت سر هم از انتهای bitmap

max → طولانی‌ترین دنباله‌ی صفرها در کل bitmap

هر بار که صفحه‌ای allocate یا free می‌شه، این summary بلافاصله به‌روزرسانی می‌شه تا Go بتونه خیلی سریع‌تر صفحات آزاد رو پیدا کنه 🚀
➖➖➖➖➖➖➖➖
👑 @gopher_academy

🧩 Bitmap Summary در مدیریت صفحات Go

در این شکل، هر بیت از bitmap نشان‌دهنده‌ی وضعیت یک صفحه‌ی حافظه است:

0 → صفحه آزاد (free)

1 → صفحه در حال استفاده (allocated)

برای بهینه‌سازی جستجوی صفحات آزاد، Go برای هر bitmap سه مقدار خلاصه‌شده (summary) نگه می‌داره:

start = 3 → یعنی در ابتدای bitmap، ۳ صفحه‌ی متوالی آزاد داریم

end = 7 → یعنی در انتهای bitmap، ۷ صفحه‌ی متوالی آزاد داریم

max = 10 → طولانی‌ترین دنباله‌ی صفحات آزاد در کل bitmap برابر با ۱۰ صفحه است

🔹 فلش در تصویر جهت افزایش آدرس حافظه (از پایین به بالا) رو نشون می‌ده.
در نتیجه، ۳ صفحه‌ی آزاد در بخش پایین‌تر حافظه (low address) و ۷ صفحه‌ی آزاد در بالاترین بخش (high address) قرار دارن.


این ساختار باعث می‌شه Go خیلی سریع‌تر بتونه محدوده‌های بزرگ از صفحات آزاد رو پیدا کنه بدون این‌که کل bitmap رو اسکن کنه — فقط با نگاه کردن به summaryها! ⚡️
➖➖➖➖➖➖➖➖
👑 @gopher_academy

🔵 عنوان مقاله
Reverse Engineering Doesn't Have to Be Hard

🟢 خلاصه مقاله:
این مطلب نشان می‌دهد مهندسی معکوس الزماً سخت نیست و با یک نمونه بدافزار نوشته‌شده با Go به‌صورت گام‌به‌گام پیش می‌رود. بدون نیاز به دانستن Go یا کدنویسی، بر روش‌شناسی تمرکز دارد: راه‌اندازی محیط امن، تریاژ اولیه (هش‌ها، فراداده و بررسی سریع رشته‌ها)، تشخیص بسته‌بندی/ابهام‌سازی، تحلیل ایستا (بررسی imports، نقطه‌های ورود، نام‌گذاری تابع‌ها، و ترسیم جریان کنترل) و در کنار آن تحلیل پویا در محیط جداافتاده برای مشاهده رفتار پردازشی، تغییرات سیستم و ترافیک شبکه. نتیجه، یک جعبه‌ابزار فشرده از تکنیک‌های پایه است که به مبتدیان اعتمادبه‌نفس می‌دهد تا منطق بدافزار را روشن کنند و نشانگرهای آلودگی (IOC) را استخراج کنند—بدون تکیه بر ترفندهای وابسته به زبان.

#ReverseEngineering #MalwareAnalysis #Golang #Infosec #StaticAnalysis #DynamicAnalysis #CyberSecurity

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

➖➖➖➖➖➖➖➖
👑 @gopher_academy

🔵 عنوان مقاله
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