بجای انتظار کشیدن؛ ویدئو ببینیم
Youtube Video

وسط build, compile, .... پروژه شرکت دیروز این رو شروع کردم و امروز دارم ویدئوهای بعدی رو ادامه میدم.
بسیار بسیار ویدئو خوبی هست.

جنگ کوانتوم.

دستاوردهای گوگل و چین رو دیدید ؟

fs::read_to_string

باگ خفته، یک سرویس کوچیک داریم که دائم down می‌شه چک می‌کنیم می‌بینیم دقیقا قبلش دیوایس (Edge Device) اونم داره ریستارت میشه.
پس نیرو میره سراغ مشکلات دیوایس؛ این وسط منم رفتم سورس کد بخونم.

اطلاعاتی هم از پروژه و مشکل داشتم و خب چندتا از بچه‌ها گفتن مشکل از دیوایس هست.

توی سورس کد دیدم طرف اینطوری داره فایل رو می‌خونه؛ یک نمونه فایل رو گرفتم (بعد از کرش کردن دستگاه)

دیدم بله، حجم فایل بیشتر از رم دستگاه شده؛ مشکل همین بود.

برای همین توی اکثر آموزش‌های حرفه‌ای از این مورد استفاده نمی‌شه و راه سخت‌تره read, buffer, ... پیش گرفته می‌شه

موضوع فقط بهینه بودن نیست؛ موضوع جلوگیری از کرش کردن هست.


گفتم اینجا هم بگم، شاید یک نفر دیگه رو هم از چندساعت دیباگ نجات داد.

این پروژه limbo خیلی باحاله و دانشگاهیه برای آموزش crate های مختلف؛ سورس کدش رو بخونید
Limbo Github

داستان اینه که اومدن گفتن SQLite رو بهتر می‌نویسیم و با یک زبان امن که خب گزینه‌اش شده Rust و اینبار همه اجازه دارند کد Contribute کنند.

من خود پروژه رو هنوز به کسی پیشنهاد نمیدم؛ ولی این خیلی خفنه مثلا برید توی سورس کد

cli/app.rs

اول اینکه هر پوشه ماژولار دیده شده و هر پوشه Cargo.toml خودش رو داره که باحال بود (دفعه اول بود می‌دیدم)

بعد توی این سورس کد مثال clap رو ببینید؛ من برای پروژه چند وقت پیشم بیچاره شدم تا همه اینارو کنار هم درک کنم و بیارم.
اینجا همش هست؛ تازه ماژولار و تر و تمیز با Best Practice ها و خوبیش اینه که هممون به اندازه کافی از SQLite می‌دونیم و دانش خوبی داریم ازش.

هلوکاست ایرانی

یک زمانی شهردار تهران رو بخاطر ترافیک تهران اعدام کردند.

آخوند جز ویرانی، برای ایران دستاورد نداشت.

Over 50% Engineers said:

Reviewing Rust codes is easier

https://github.com/pykeras/neovim

بالاخره آماده شد.

تست هم رفتیم با ۸ نفر از دوستان و ۲ تا از بچه‌های گروه خودمون.

فکر می‌کنم خوب باشه.

توی ReadMe اصل داستان رو گفتم؛ نکاتی هم برای آنان که می‌اندیشند وجود داره

Fish shell

رو با بازنویسی کامل روی Rust برای نسخه 4 خواهیم داشت.

ازون گیت‌هابای پر از درس هست که خیلی خوب میشه سورس کدش رو خوند.
پروژه Limbo رو که یادتون هست ؟

https://news.1rj.ru/str/pyrust/110

تو زندگیم ۲-۳ بار برای پروتوتایپ ایده‌ رفتم سمت Electron و قسم می‌خورم حتی ۲ مورد که سرمایه‌گذار داشته رو بعد از ۲ هفته ازش زدم بیرون چون بنظرم احمقانه بود و بعد از اون هیچوقت فکر نمی‌کردم بخوام برم سراغ اینکار

چندروزی هست دارم روی کار با Tauri وقت میذارم؛ شرکتی که باهاش کار می‌کنم چند وقت یکبار مسابقه ۱-۲ روزه میذاره سر اپتیمایز کردن برنامه‌ها و پروژه‌های موفق و جایزه درخوری هم میده (شرکت کننده‌ها هم براشون ساعت کاری رد میشه) دیگه گفتم ی جایزه‌ای بگیریم سیستم رو جایگزین کنم.

توی همین راستا رسیدم به یک مصاحبه خوب؛ توی این مسابقه طراحی سیستم؛ چرایی انتخاب‌ها و بعد پیاده‌سازی دمو اولیه خیلی مهمه منم از الان شروع کردم روش کار کردن (چون برای اینکه جایزه جواب آپگرید رو بده مجبورم یا تنها پیش برم یا نهایتا تیم رو دونفره ببندم)

Youtube Link

شما جایگزین بهتری می‌شناسید ؟

در ادامه تمرین‌های Rust رو آوردم به Dioxus چرا ؟
فقط چون با Rust میشه فرانت‌اند وب زد

البته توی داکیومنتش گفته که از Tauri هم استفاده می‌کنند برای desktop build های مختلفی که دارند و شاید بهتر باشه منم برم سراغ همین تا Tauri (فعلا روی بکند و tui هستم)

https://dioxuslabs.com

هفته پیش اولین پروژه Rust خودم رو تحویل دادم.

یک ابزار تحت ترمینال برای آنالیز فایل (تعداد خیلی بالا) بود.
توی پایتون نوشته شده بود، می‌خواستند بیارنش روی Rust و یکسری ویژگی جدید هم بهش اضافه کنند.
هرچند من بعد از خوندن کدها بهشون اطلاع دادم که کد پایتون درست نوشته نشده و همون باعث کند بودن هست و می‌تونم درستش کنم ولی به خواست خودشون رفتم روی Rust امروز تأیید خروجی و تست‌ها و پرداخت انجام شد و شد اولین دستمزد Rust من و سریعترین درآمد مبلغ خوبم از یادگیری زبان برنامه‌نویسی جدید.

البته این درآمد نشه موضوعی برای اینکه برید Rust یادبگیرید، چون قطعاً تجربیات دیگری که داشتم باعث شد این پروژه رو بگیرم.

اما، خواستم این رو بگم که بیشترین کمک رو بهم، خوندن سورس کد دیگران کرد.
مثلاً پروژه Limbo که بالاتر گفتم، خیلی خیلی کمکم کرد که توی ۱ روز تمام دستورات cli پروژه رو بزنم.

ازم درخواست tui کردند که گفتم درحال حاضر وقتش رو ندارم و حقیقتا تا حالا هم tui برای Rust نخوندم.
احتمالاً بعد از خوندن ۲-۳ تا سورس کد دیگری که در دستم هست و تمرین کردنشون برم سراغ یادگیری پکیج‌های tui و بعد از اون Tauri یا Dioxus ولی این موضوع انگیزه شد مضاعف برای ادامه مسیر.

خیلی هم عالیه :

I love Rust

یک موضوعی از شب قبل رفته توی مغزم
#5min_Rust

بعد پست بالا توی کانال، Intec یکی از بچه‌ها چندتا سوال Rust داشت که تونستم جواب بدم.

وقتی متوجه شدند این کانال وجود داره، پیشنهاد دادند که توی این کانال روزانه یا ... پستهای آموزش Rust بذارم.

از مباحث ساده شروع کنیم.

حقیقتا پیشنهاد خوبی بود (اگر بتونم خوب هم انجامش بدم) متن کوتاه باشه که از حوصله کسی خارج نشه.

و شدنی هم هست، چون برخلاف کانال پایتون که هدف تخصصی صحبت کردن بود.
اینجا هدف شروع مقدمات هست.

نمی‌دونم نهایتاً چی میشه ولی تلاشم رو می‌کنم، امیدوارم چیز خوبی بشه ولی اگر نشد شما بهم بگید 🌹

از امشب شروع کنیم

بخش‌های اول که ساده‌تر هست رو سعی می‌کنم بیشتر بگم (که سریع ازشون بگذریم)

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

مفاهیم software enginnering رو توی زبان برنامه‌نویسی که باهاش تجربه دارید بخوبی بلد باشید.

اگر این ویژگی رو ندارید، یا Rust اولین زبان برنامه‌نویسی هست که یاد می‌گرید؛ نمی‌گم شدنی نیست ولی قراره روزای سختی رو داشته باشید پس نیاز به انگیزه قوی داره.

نکته آخر: اگر Rust رو برای کسب درآمد و سرکار رفتن می‌خواید، زبان و گزینه خوبی نیست حداقل درحال حاضر در ایران و اروپا.


فکر نکنم نکته دیگه‌ای لازم باشه، همه می‌تونند Rust رو یاد بگیرند.

ازونجایی که بکگراند خیلی‌ها توی کانال python هست ترجیح میدم با چرایی Rust شروع کنم (هرچند برای خودم دلیلی نداشت؛ نشستم کد زدم و لذت بردم و به اینکار ادامه دادم.)

خیلی از پست‌ها ممکنه شوخی توش باشه (خودم اینطوری یادم می‌مونه) و اینکه ممکنه ۱۰۰٪ درست نباشه متن اما برای ساده‌سازی و درک بهتر تصمیم گرفتم از یکسری چیزا بگذرم؛ هرچی پیشرفته تر بشیم بر میگردیم به عقب و اون موارد رو هم تصحیح می‌کنیم.

#5min_Rust

اصن چرا Rust ؟ چرا Chap نه ؟
اسمش از یک قارچ اومده که عملکرد خیلی باحالی داره (بخونید راجبش)

دو مدل مدیریت حافظه داریم:
یا دست خود برنامه‌نویس می‌سپارید و میگیم برو به امان خدا.
یا آشغال جمع‌کنی (garbage collector) می‌ذاریم و می‌گیم اعتمادی به برنامه‌نویس نیست.

حالت اول میشه زبان‌هایی مثل C/C++ و بزرگترین مشکل کدهاش اینه که ی آدرس از یک خونه حافظه داریم که داره به یک جایی اشاره می‌کنه؛ حالا اون نقطه از خونه حافظه رو توی یک بخش دیگه کدهامون اومدیم خالی کردیم (دیتایی نداره).

فرض کن من یک خونه حافظه گرفتم و توی اون حاصل یک سری محاسبات رو بصورت String ذخیره کردم و یک اشاره‌گر به اون خونه حاقظه رو توی کدم دارم (آدرسش رو گرفتم بعدا با بچه‌ها مزاحم بشیم)؛ یک جای دیگه کدهام توی یک تابع دیگه بعدها اومدم اون خونه حاقظه رو گرفتم و یک سری کار باهاش کردم و دوباره ذخیره کردم همونجا؛ بیاید فرض کنیم این کارا که کردم یک پسورد رو براساس String اولیه ساخته.

اون آدرس رو اگر یادم رفته باشه آپدیتش کنم یا ... و هنوز به این خونه حافظه دسترسی داشته باشه اون وقت به فنا رفتم؛ همونطور که دوس ندارید لخت دوس دختر/دوس پسرتون رو کسی ببینه؛ پسورد لختتون رو هم نمی‌خواید با رفقا به خونه حافظه‌اش سر بزنید.

پس یک مشکل اساسی اینجاس (خیلی ساده گفتم کسی یادش نره)

حالت دوم زبان‌هایی مثل Python/Java می‌شه یکی هست به اسم آشغال جمع کن که وقتی خونه حافظه قابل دسترسی نیست یا رفرنس دیگه استفاده اولیه‌اش رو نداره اینارو حذف می‌کنه.
خب مشکلمون حل شد بریم خونمون ؟

مسئله اینجاس که دست دوم زبان‌ها سربار دارند و بدرد کارهای Realtime, Mission Critical نمی‌خورند دسته اول هم که بدرد میخوره وقتی پروژه گنده میشه تا دلتون بخواد باگ می‌کوبه تو صورت دولوپرها.

اما زبان Rust اومد با یک ایده دیگه (با پیاده سازی درست) :
گفت من یک کاری انجام میدم که Garbage Collector نمی‌خوام ولی مموری رو امن میدم در اختیارت که بری عشق کنی.
همه چیز اینجا صاحاب داره و تا صاحابش اجازه نده؛ نگاشم نمی‌تونی بکنی.
همین مورد چندین مشکل رو حل کرد:
۱- دستبرسی به خونه خالی نداریم: null dereferencing
۲- هیچ اشاره‌گری رو معلق نمی‌ذاریم بریم: dangling pointer
۳- اصراف هم نمی‌کنیم چون کار خوبی نیست: buffer overflow

حل همین ۳ تا مشکل باعث شد Rust کلی مرید پیدا کنه. ولی مسئله سرعت اجرا چی ‌میشه ؟ Rust اومد گفت بذارید دولوپر اذیت بشه ولی کاربر نشه چون شما یک کد رو ۱ بار می‌نویسی ولی ممکنه میلیون‌ها بار اجرا بشه پس همه بررسی‌های مربوط به قوانین همه چیز صاحاب داره؛ بی‌صاحابی در زمان کامپایل بررسی میشه.

یعنی چیزی دستت رو نمی‌گیره مگر اینکه قوانین رو رعایت کرده باشی (حالا جلوتر می‌بینیم خودش چقدر خوب مشکلاتت رو بهت می‌گه) چی شد که مریداش سر به بیابان گذاشتن (بله گونه‌های اولیه خشتک به دهان.) هیچی Rust گفت همه هزینه‌هاتون با من شما پرفورمنس C بهت تحویل داده می‌شه.

#5min_Rust

برای نصب rust روی سیستم؛ به rust-lang سر بزنید اگر از لینوکس استفاده می‌کنید ۱ خط دستور رو توی ترمینال می‌زنید؛ اگر اینترنت ضعیف باشه ی چایی بریزی برگردی نصب شده.

اگر روی vs-code کد میزنید؛ بعدش حتما rust-analyzer رو نصب کنید. اگر روی Pycharm کد میزنید که برید یک محصول دیگه رو هم بخرید 😂
اگر روی Neovim هستید هم که؛ چایی دم کردم ناراحت می‌شم جای دیگه برید یک سری به github خودم بزنید.

نصب کنید که از پست بعدی کد هم بزنید.

#5min_Rust

بعد از نصب rust برای ایجاد اولین پروژه از cargo استفاده می‌کنیم. با دستور cargo new pyrust شما یک پوشه جدید توی مسیری که این دستور رو اجرا کردید خواهید داشت به اسم pyrust.

تمام پروژه‌هایی که با cargo ایجاد می‌شوند حتما اسکلت مشابه دارند (مثال زیر)

.
├── Cargo.toml
├── .git
├── .gitignore
└── src
    └── main.rs

قبل از بررسی فایل‌ها باید بگم که؛ این یک پروژه باینری هست (درآینده بررسی خواهیم کرد ولی اگر کتابخونه بود بجای main.rs شما lib.rs می‌دیدید)

تمام پروژه‌هایی که با cargo ایجاد می‌شوند بصورت خودکار git, gitignore رو خواهند داشت بریم باقی رو بررسی کنیم.

1) Cargo.toml

[package]
name = "pyrust"
version = "0.1.0"
edition = "2021"

[dependencies]

این فایل شامل اطلاعات پروژه هست؛ بخش dependencies بخشی هست که موقع استفاده از لایبراری‌های دیگه (ازین به بعد بهشون میگیم crate چون اسمش توی Rust این هست) باید پر کنید تا cargo اونهارو دانلود و استفاده کنه.

یک نکته دیگه که کمتر دقت میشه بهش؛ edition هست با این معنی که این پکیج باینری تا نسخه‌ای که سال 2021 منتشر شد backward compatibility رو داره.

شما ۳ تا ادیشن رو ممکنه ببینید :
۲۰۱۵ نسخه‌ای که Rust منتشر شد.
۲۰۱۸ نسخه‌ای که module, async/await و ... منتشر شد.
۲۰۲۰ نسخه‌ای که استانداردهای خیلی خوبی برای closure, iterate, ... منتشر شده.

همه چیز در Rust از src/main.rs و تابعی به اسم main شروع می‌شه؛ پس اگر پکیج باینتری داشته باشید حتما باید این موارد رو هم داشته باشید :

2) main.rs

fn main() {
    println!("Hello, world!");
}

بصورت پیشفرض داخلی این فایل hello world رو خواهید داشت؛ fn کلمه کلیدی برای تعریف تابع هست main اسم تابع که هیچ آرگومانی بعنوان ورودی نمیگیره و هیچ چیزی هم بر نمی‌گردونه یا اصطلاحا unit type برمیگرده به () میگیم unit type و وقتی یک تابعی () بر میگردونه دیگه نیازی نیست اون رو بنویسیم اما اگر توی کد بالا می‌خواستیم بگیم که تابع main فقط unit type برمی‌گردونه کد به اینصورت م+یشد :

fn main() -> () {...}

از {} ها برای نمایش اسکوپ تابع (از کجا تا کجای کد مال این تابع هست) استفاده میشه همونطوری که توی پایتون برای اینکار از indentation استفاده می‌شه.
داخل این تابع فقط قرار هست یک متنی رو توی ترمینال چاپ کنیم؛ برای چاپ متن داخل ترمینال از println استفاده میشه که بعد از چاپ متن میره خط بعدی اگر نخواستیم بره خط بعدی از print استفاده می‌کنیم.

println!(), print!()

اما اگر دقت کنید توی کد بالا هم print و هم println هردو کنار اسمشون ! اومده؛ این ! اشتباه نیست و توی Rust یک مفهومی رو معرفی می‌کنه به اسم Macro پس نه print و نه println هیچکدوم تابع نیستند.

خیلی خلاصه بخوام بگم؛ وقتی کامپایلر یک macro توی کد شما می‌بینه می‌دونه که باید اون بخش از کدشما رو برداره و بر اساس یک الگوی خاص کد دیگری رو با پارامتر ورودی شما جایگزینش کنه.
در آخر هم توجه شمارو به ; جلب می‌کنم.

قبل از اجرای کد؛ اگر از rust-analyzer استفاده می‌کنید حتما باید داخل پوشه‌ای باشید که Cargo.toml قرار داره.

❯ cargo run
   Compiling pyrust v0.1.0 (/home/mo.abbasi/Desktop/codes/learning/rust/pyrust)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.64s
     Running `target/debug/pyrust`
Hello, world!

رو می‌تونید برای اجرای پروژه استفاده کنید؛ اگر از cargo run برای اجرا استفاده کنید نسخه‌ای که کامپایل میشه نسخه development هست و برای اینکه سریعتر کامپایل انجام بشه unomptimized هست (که توی توضیحات هم چاپ میشه) اگر توی نسخه develop نخواستید این توضیحات رو ببینید از دستور cargo run -q استفاده کنید.

بعد از اولین اجرا یا به محض فعال شدن rust analyzer؛ ۱ فایل و ۱ پوشه جدید توی پروژه خواهید دید. Cargo.lock که هیچوقت بهش دست نمیزنیم و جزئیات dependency هارو نگه میداره و البته پوشه target که نسخه کامپایل رو نگه می‌داره چون پروژه رو تو حالت development/debug کامپایل کردیم الان می‌تونیم فایل باینتری - کامپایل شده رو از پوشه target هم ببینید و اجرا کنیم :

target/debug/pyrust

تبریک می‌گم شما با ساختار اصلی و اولیه پروژه باینری در Rust آشنا شدید.

با صحبت امروز پزشکیان
من روی دلار ۱۱۰,۰۰۰ تومان دارم می‌بندم.

آخر سال تمام قراردادهای همکاری داخلیم تموم می‌شه و دستمزد جدید رو بر این اساس می‌گیرم، البته که دارم فرض می‌کنم دلار تا چندروز آینده به ۱۰۰,۰۰۰ تومان برسه و مدتی همین حوالی باشه‌.

اگر دلار واقعاً به ۱۱۰,۰۰۰ تومان برسه (که اصلاً بعید نیست)
قراردادهای سال بعدی رو روی دلار ۱۳۰,۰۰۰ تومان می‌بندم.

به ۲ دلیل این رو میگم:

۱- بچه‌های سنیور گفتند چطوری دستمزد بدیم برای سال بعد.

۲- چند نفر دعوت به همکاری کردن، گفتم حدود دستمزد رو بدوند که وقت هم رو نگیریم.

دستمزد فعلی رو بر اساس دلار ۶۰,۰۰۰ تومان بسته بودم سال قبل که خدا بیامرزش.

#5min_Rust

انواع روش‌های لیبل زدن برای مقادیر رو توی این پست بررسی کنیم؛ معمولا این رو با اسم متغییر می‌شناسیم ولی خب توی زبان‌های مثل Rust اسم متغییر کمی گیج کننده هست. چرا ؟

اول با immutable, mutable شروع کنیم (تغییر پذیر و تغییر ناپذیر) :
بصورت پیش‌فرض تمام متغییرهایی که توی Rust تعریف می‌کنیم تغییرناپذیر هستند و برای تعریف یک متغییر از کلید let استفاده می‌شه یک مثال ببینیم:

let channel = "pyrust";

اگر بصورت immutable یک متغییر رو تعریف کنید تا آخر نمی‌تونید مقدارش رو تغییر بدید؛ اما توجه کنید با اینکه زبان Rust زبان Static type هست من توی این مثال type متغییر رو تعریف نکردم (راجب type ها تصمیم گرفتم بعد این پست صحبت کنم چون آموزش ویدئویی نیست و برای مثال زدن روی اون موارد باید این پست خونده می‌شد) فعلا بیاید قبول کنیم که "pyrust" توی مثال بالا از نوع داده اصطلاحا string slice هست. خود کامپایلر انقدر باهوش هست که شما نیازی ندارید این type هارو بهش بگید و می‌تونه خودش حدس بزنه ولی اگر خواستید بصورت دستی بهش تایپ هم بدید :

let channel: &str = "pyrust";

از کلمه let برای تعریف متغییر استفاده می‌شه؛ بعد از اون اسم متغییر میاد که اینجا channel هست و بعد از اون : &str که معلوم می‌کنه این متغییر از چه نوع داده‌ای باید باشه و هست باقیشم که توی همه زبان‌ها یکسان هست.
اما اگر بخوایم یک متغییر تعریف کنیم و به کامپایلر بگیم در طول اجرای برنامه این متغییر اجازه داره مقدارش عوض بشه چطور ؟ فقط کافیه از کلمه کلیدی mut (مختصر شده mutable استفاده کنیم) :

let mut channel: &str = "pyrust";

تنها تفاوت اینه که قبل از اسم متغییر (channel) باید mut رو بذارید.
این موارد رو تست کنید:

fn main() {
    let channel = "pyrust";
    channel = "pyhints";
    println!("Channel is: {}", channel);
}

اگر به ارور کامپایلر (یا rust-analyzer) دقت کنید؛ می‌بینید که علاوه بر اینکه ارور رو بهتون می‌گه راهکار رو هم بهتون نشون میده؛ تستش کنید.

fn main() {
    let mut channel = "pyrust";
    channel = "pyhints";
    println!("Channel is: {}", channel);
}

توی مثال بالا مقداری warning می‌گیرید که اهمیتی نداره فعلا؛ اما حتی وقتی متغییر رو mut بکنید اجازه ندارید نوع داده داخلش رو عوض کنید:

fn main() {
    let mut channel = "pyrust";
    channel = 1590;
    println!("Channel is: {}", channel);
}

این متغییر تا آخر باید از نوع string slice بمونه؛ البته با shadowing می‌شه از همین اسم مجدد استفاده کرد ولی اون موضوع برای آینده هست.

بعد از let به یک کلمه کلیدی دیگه میرسیم به اسم const مخفف constant برای تعریف مقادیر ثابت استفاده می‌شه و حتما هم باید بهشون type رو بدید اولین نکته درباره const در Rust اینه که مقدارش حتما باید قبلا از کامپایل بهش داده بشه.
این یعنی شما نمی‌تونی نتیجه محاسبات یا دیتای ورودی کاربر و ... رو توی const نگهدارید.

const OWNER: &str = "Mo.Abbasi";

fn main() {
    let channel = "pyrust";
    println!("Channel {channel} owner is {OWNER}");
}

توی این مثال چندتا نکته هست:
اول؛ const می‌تونه بعنوان global variable تعریف بشه؛ خارج از محدوده main. توی چندین scope جا میگیره تابع؛ ماژول و یا گلوبال (راجب scope هم مثال خواهم زد).
دوم؛ همیشه برای اسم constant ها از حروف بزرگ باید استفاده بشه.
سوم؛ println هست که می‌تونم اسم متغییر رو داخل {} بذارم؛ راحتر از موارد قبلی.

در نهایت آخرین مورد static هست؛ مثل const باید تایپ رو بهش بدید؛ مثل let هم mut, immut داره (که البته ۹۹٪ سعی کنید از mut اش استفاده نکنید.) مقدارش می‌تونه در زمان کامپایل یا در زمان initialize کردن برنامه مشخص بشه (مثلا config مربوط به اجرای برنامه‌)
خوبیش اینه که از شروع کار برنامه تا خروج ازش می‌تونید بهش دسترسی داشته باشید اصطلاحاْ liftime اش به اندازه خود پروسس کد اصلی هست.


توی تمام مثال‌های بالا بیشتر تفاوت و استفاده‌ها به lifetime, scope برمی‌گرده اما با همین توضیحات ساده هم شما باید بتونید تشخیص بدید چه زمانی از کدوم استفاده کنید.
نکته بعدی نحوه مصرف مموری هست؛ این رو فقط بعنوان رفرنس میذارم چون جلوتر بررسی خواهیم کرد (پست‌های آینده)

let: Stack/Heap depending on the data type.
const: Compiler inline / memory location.
static: Static memory region.

لحظه نوشتن متن بالا مثال خوبی برای static یادم نیومد.
اما گفتم یکی از استفاده‌هاش برای Singleton هست؛ برای مثال اینجا مطمئن میشم همه تست‌ها فقط یکبار اجازه صدا زدن کد رو دارند.

نمیدونم چرا این کتاب رو نخوندم و ندیده بودم (سرفصل‌هاش رو)

بسیار کتاب جذاب و خوبی هست؛ بله درسته با Rust 2018 هست ولی واقعا مهم نیست.
متوجه شدم یکی از دوستانی که توی گوگل دارم؛ تغییر Stack داده از C به Rust ایشون توی تیم کروم بودند.
کلی باهاش صحبت کردم؛ چون توی این مدت بسیار به نوشتن کرنل علاقمند شدم و خودم دارم روش کار می‌کنم (کند پیش میرم چون تسک‌های دیگه دارم ولی پیش میرم.)
ازش خواستم توی این موضوع بهم کمک کنه منابعی که خوندم رو بهش دادم؛ چندتا سوال ازم پرسید (مثل مصاحبه) و بعد این منبع رو بهم داد:
Programming Rust 2nd Edition

خوشحال شدم که همین اول مسیر یکی مشکلاتم رو بهم گفت؛ ناراحت شدم ازینکه با این تجربه چرا این کتاب رو نخوندم؛ دلیلش رو هم می‌دونم.

خیلی سال هست توی دنیای پایتون - هوش مصنوعی بودم؛ توی اون دنیا سرعت تغییراتی که باقی چیزها رو خراب کنه خیلی زیاده (بیش از حد) برای همین منبع ۳ سال قدیمی خیلی به کار نمیاد تازه منابع یادگیری هم خیلی زیاد و راحت در دسترس هست؛ اشتباه کردم با اون دید توی دنیای Rust دنبال منبع گشتم.

حالا اولویتم این کتاب هست؛ تا شنبه بنظرم بتونم ۱۲-۱۳ فصل اول رو بخونم و تمرین کنم.
یا اصطلاح دید یک سری منابع دیگه هم پیدا کردم که زیر این پست میذارم اگر دوست داشتید بررسی کنید.

۱- این از یک دوره اومده که certificate می‌داده برای Rust بنظرم برای مصاحبه خوبه چون تمرینات خوب و سوال جوابای خوبی داره (با اصطلاحات به خوبی آشنا می‌شید)
RustCamp
۲- موارد خیلی مهم مربوط به trait های standard library رو توی این مورد پیدا می‌کنید؛ کسایی که با Rust کمی جدی کد زده باشند می‌دونند که خیلی وقتا باید این موارد رو بشناسی تا برای struct, enum, ... خودت تعریفشون کنی و زندگی رو راحت کنی
Tour of std

۳- از همون نویسنده قیلی این پستش هم خیلی خوبه؛ اشتباهات رایج توی درک Lifetime رو اینجا گفته
Lifetime Misconceptions

۴- از سایت تمرینات راست هم این مورد خیلی خوبه (من تمرین کردن رو از خوندن بیشتر دوس دارم) :
100 Exercises to learn Rust

۵- در نهایت اینم چون از دنیای پایتون اومدم:
Rust-Python interoperability

شخصا به ترتیب با اولویت کتاب توی وقتهای خالی دارم این مورد رو پیش می‌برم.