کتاب Asynchronous Programming in Rust

کتاب Asynchronous Programming in Rust: Learn asynchronous programming by building working examples of futures, green threads, and runtimes (برنامه نویسی ناهمزمان در Rust: برنامه نویسی ناهمزمان را با ساختن نمونه های کاری از آینده ها، موضوعات سبز و زمان اجرا بیاموزید) برای برنامه‌نویسانی است که می‌خواهند درک خود را از برنامه‌نویسی ناهمزمان افزایش دهند، به ویژه کسانی که در زبان‌های VM یا ترجمه شده مانند C#، Java، Python، JavaScript و Go تجربه دارند.

اگر با C یا C++ کار می‌کنید اما در معرض برنامه‌نویسی ناهمزمان محدودی بوده‌اید، این کتاب به عنوان منبعی برای گسترش دانش شما در این زمینه عمل می‌کند.

در ادامه مقدمه‌ای از کتاب Asynchronous Programming in Rust را از زبان نویسنده شرح خواهیم داد.

مقدمه‌ای بر کتاب Asynchronous Programming in Rust:

محتوای این کتاب در ابتدا به‌عنوان مجموعه‌ای از کتاب‌های کوتاه‌تر برای برنامه‌نویسانی نوشته شد که می‌خواهند برنامه‌نویسی ناهمزمان را از ابتدا با استفاده از Rust یاد بگیرند. به نظر من مطالب موجودی که در آن زمان به آن دست یافتم، به طور مساوی ناامید‌کننده، روشنگر و گیج‌کننده بود، بنابراین می‌خواستم کاری در مورد آن انجام دهم.

آن کتاب‌های کوتاه‌تر محبوب شدند، بنابراین وقتی این فرصت را پیدا کردم که همه چیز را برای بار دوم بنویسم، بخش‌هایی را که از آن راضی بودم بهبود بخشم، و همه چیز‌های دیگر را کاملاً بازنویسی کنم و آن‌ها را در یک کتاب واحد و منسجم قرار دهم، فقط مجبور شدم این کار را انجام دهم. نتیجه درست در مقابل شماست.

افراد به دلایل مختلف شروع به برنامه‌نویسی می‌کنند. دانشمندان شروع به برنامه‌نویسی برای مدل‌سازی مسائل و انجام محاسبات می‌کنند. کارشناسان کسب و کار برنامه‌هایی را ایجاد می‌کنند که مشکلات خاصی را حل می‌کند که به کسب و کار آن‌ها کمک می‌کند. برخی افراد برنامه‌نویسی را به عنوان یک سرگرمی یا در اوقات فراغت خود شروع می‌کنند. مشترک این برنامه‌نویسان این است که برنامه‌نویسی را از بالا به پایین یاد می‌گیرند.

بیشتر اوقات، این کاملاً خوب است، اما در مورد موضوع برنامه‌نویسی ناهمزمان به طور کلی، و Rust به طور خاص، مزیت آشکاری برای یادگیری در مورد موضوع از اصول اولیه وجود دارد، و هدف این کتاب ارائه ابزاری برای انجام درست است.

بیشتر بخوانید: کتاب Zero To Production In Rust

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

برنامه‌نویسی ناهمزمان، به دلیل ماهیت خود، بر کل جریان برنامه تأثیر می‌گذارد و بسیار تهاجمی است. برنامه‌ای را که می‌نویسید، بازنویسی، مرتب‌سازی و زمان‌بندی می‌کند، به گونه‌ای که همیشه برای شما به عنوان یک برنامه‌نویس واضح نیست.

بیشتر زبان‌های برنامه‌نویسی سعی می‌کنند برنامه‌نویسی ناهمزمان را آنقدر آسان کنند که شما واقعاً نیازی به درک نحوه عملکرد آن نداشته باشید تا در آن کارآمد باشید.

می‌توانید Rust ناهمزمان را کاملاً سازنده بنویسید بدون اینکه واقعاً بدانید که چگونه کار می‌کند، اما Rust واضح‌تر است و پیچیدگی بیشتری را برای برنامه‌نویس نسبت به بسیاری از زبان‌های دیگر نشان می‌دهد. اگر درک عمیقی از برنامه‌نویسی ناهمزمان به طور کلی و آنچه واقعاً هنگام نوشتن Rust ناهمزمان رخ می‌دهد، به دست‌آورید، زمان بسیار آسان‌تری برای مدیریت این پیچیدگی خواهید داشت.

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

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

کتاب Asynchronous Programming in Rust برای افرادی ساخته شده است که ذاتاً کنجکاو هستند، برنامه‌نویسانی که می‌خواهند سیستم‌هایی را که استفاده می‌کنند درک کنند، و دوست دارند آزمایش‌های کوچک و بزرگ را به عنوان راهی برای کاوش و یادگیری ایجاد کنند.

کتاب Asynchronous Programming in Rust برای چه کسی است؟

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

کتاب Asynchronous Programming in Rust برای کسانی که دوست دارند نمونه‌های کاری بنویسند که می‌توانند آن‌ها را جدا کنند، گسترش دهند و آزمایش کنند، عالی است. دو نوع شخصیت وجود دارد که به نظر من این کتاب به ویژه به آن‌ها مربوط است:

برنامه‌نویسانی که از زبان‌های سطح بالاتر با جمع‌آوری زباله، مفسر یا زمان اجرا، مانند C#، Java، JavaScript، Python، Ruby، Swift یا Go می‌آیند. برنامه‌نویسانی که تجربه گسترده‌ای با برنامه‌نویسی ناهمزمان در هر یک از این زبان‌ها دارند اما می‌خواهند آن را از پایه یاد بگیرند و برنامه‌نویسانی که هیچ تجربه‌ای در برنامه‌نویسی ناهمزمان ندارند، هر دو باید این کتاب را به یک اندازه مفید بدانند.

توسعه‌دهندگان با تجربه در زبان‌هایی مانند C یا C++ که تجربه محدودی در برنامه‌نویسی ناهمزمان دارند.

آنچه کتاب Asynchronous Programming in Rust پوشش می‌دهد:

فصل ۱، برنامه‌نویسی همزمان و ناهمزمان: یک مرور کلی، تاریخچه کوتاهی را به نوع برنامه‌نویسی ناهمزمان که امروزه استفاده می‌کنیم، ارائه می‌دهد. ما چندین تعریف مهم ارائه می‌دهیم و یک مدل ذهنی ارائه می‌دهیم که توضیح می‌دهد برنامه‌نویسی ناهمزمان واقعاً چه نوع مشکلاتی را حل می‌کند و چگونه همزمانی با موازی‌سازی متفاوت است.

ما همچنین اهمیت انتخاب چارچوب مرجع صحیح را هنگام بحث در مورد جریان برنامه ناهمزمان پوشش می‌دهیم و چندین مفهوم مهم و اساسی در مورد CPU‌ها، سیستم عامل‌ها، سخت‌افزار، وقفه‌ها و I/O را مرور می‌کنیم.

فصل ۲ کتاب Asynchronous Programming in Rust، چگونه زبان‌های برنامه‌نویسی جریان برنامه‌های ناهمزمان را مدل‌سازی می‌کنند، محدوده فصل قبل را محدود می‌کند و بر روش‌های مختلف برخورد زبان‌های برنامه‌نویسی با برنامه‌نویسی ناهمزمان تمرکز می‌کند. با ارائه چندین تعریف مهم قبل از توضیح کوروتین‌های پشته‌ای و بدون پشته، رشته‌های سیستم عامل، رشته‌های سبز، فیبر‌ها، تماس‌های برگشتی، وعده‌ها، آتی‌ها و async/wait شروع می‌شود.

فصل ۳ کتاب Asynchronous Programming in Rust، درک صف‌های رویداد، تماس‌های سیستمی، و انتزاع‌های بین پلتفرم‌های مبتنی بر سیستم عامل، توضیح می‌دهد که epoll، kqueue و IOCP چیست و چگونه تفاوت دارند. با ارائه مقدمه‌ای بر syscalls، FFI و انتزاع‌های چند پلتفرمی، ما را برای فصل‌های بعدی کتاب Asynchronous Programming in Rust آماده می‌کند.

فصل ۴ کتاب Asynchronous Programming in Rust، صف رویداد خود را ایجاد کنید، فصلی است که در آن صف رویداد خود را ایجاد می‌کنید که از API mio (کتابخانه محبوب Rust که زیربنای بسیاری از اکوسیستم همگام فعلی است) تقلید می‌کند. این مثال حول محور epoll خواهد بود و به جزئیات کامل نحوه عملکرد آن می‌پردازد.

فصل ۵ کتاب Asynchronous Programming in Rust، ایجاد فیبر‌های خودمان، به مثالی اشاره می‌کند که در آن ما نوع خود را به نام فیبر‌ها ایجاد می‌کنیم. آن‌ها همان رشته‌های سبز رنگی هستند که Go از آن استفاده می‌کند و یکی از رایج‌ترین و محبوب‌ترین جایگزین‌ها را برای نوع انتزاعی که Rust با قرارداد‌های آینده و async/wait امروز استفاده می‌کند، نشان می‌دهد. Rust از این نوع انتزاع در روز‌های اولیه خود قبل از رسیدن به ۱. ۰ استفاده کرد، بنابراین بخشی از تاریخ Rust نیز هست.

این فصل از کتاب Asynchronous Programming in Rust، همچنین چندین مفهوم کلی برنامه‌نویسی مانند پشته‌ها، اسمبلی، رابط‌های باینری برنامه (ABIs) و معماری مجموعه دستورالعمل‌ها (ISA) را پوشش می‌دهد که فراتر از زمینه برنامه‌نویسی ناهمزمان نیز مفید هستند.

فصل ۶، Futures in Rust، به معرفی کوتاه و نمای کلی از آینده، زمان اجرا و برنامه‌نویسی ناهمزمان در Rust می‌پردازد.

فصل ۷، Coroutines و async/wait، فصلی است که در آن برنامه‌های مشترک خود را می‌نویسید که نسخه‌های ساده‌شده‌ای هستند که امروز توسط async/wait در Rust ایجاد شده‌اند. ما تعدادی از آن‌ها را با دست می‌نویسیم و نحو جدیدی را معرفی می‌کنیم که به ما اجازه می‌دهد تا به صورت برنامه‌نویسی آنچه را که شبیه توابع معمولی به نظر می‌رسد در برنامه‌هایی که با دست نوشته‌ایم بازنویسی کنیم.

فصل ۸، Runtimes، Wakers و Reactor-Executor Pattern، زمان اجرا و طراحی زمان اجرا را معرفی می‌کند. با تکرار مثالی که در فصل ۷ کتاب Asynchronous Programming in Rust ایجاد کردیم، یک زمان اجرا برای برنامه‌های خود ایجاد می‌کنیم که به تدریج آن را بهبود خواهیم بخشید. ما همچنین آزمایش‌هایی را با زمان اجرا انجام خواهیم داد تا نحوه عملکرد آن را بهتر درک کنیم.

فصل ۹، Coroutines، Self-Referential Structs و Pinning، فصلی است که در آن ساختار‌های خودارجاعی و پینینگ در Rust را معرفی می‌کنیم. با بهبود بیشتر برنامه‌های کاری خود، به طور مستقیم متوجه می‌شویم که چرا به چیزی مانند پین نیاز داریم و چگونه به ما در حل مشکلاتی که با آن مواجه می‌شویم کمک می‌کند.

فصل ۱۰، زمان اجرای خود را بسازید، فصلی است که در نهایت تمام قطعات را کنار هم قرار می‌دهیم. ما همان مثال را از فصل‌های قبلی کتاب Asynchronous Programming in Rust بیشتر بهبود می‌دهیم تا بتوانیم قرارداد‌های آتی Rust را اجرا کنیم که به ما امکان می‌دهد از قدرت کامل async/wait و Rust ناهمزمان استفاده کنیم. ما همچنین چند آزمایش انجام خواهیم داد که برخی از مشکلات مربوط به Rust ناهمزمان را نشان می‌دهد و چگونه می‌توانیم آن‌ها را به بهترین شکل حل کنیم.

سرفصل‌های کتاب Asynchronous Programming in Rust:

• Cover
• Title Page
• Copyright
• Dedication
• Contributors
• Table of Contents
• Preface
• Part 1: Asynchronous Programming Fundamentals
  • Chapter 1: Concurrency and Asynchronous Programming: a Detailed Overview
  • Chapter 2: Concurrency and Asynchronous Programming: a Detailed OverviewHow Programming Languages Model Asynchronous Program Flow
  • Chapter 3: Understanding OS-Backed Event Queues, System Calls, and Cross-Platform Abstractions
• Part 2: Event Queues and Green Threads
  • Chapter 4: Create Your Own Event Queue
  • Chapter 5: Creating Our Own Fibers
• Part 3: Futures and async/await in Rust
  • Chapter 6: Futures in Rust
  • Chapter 7: Coroutines and async/await
  • Chapter 8: Runtimes, Wakers, and the Reactor-Executor Pattern
  • Chapter 9: Coroutines, Self-Referential Structs, and Pinning
  • Chapter 10: Creating Your Own Runtime
• Index
• About PACKT
• Other Books You May Enjoy

جهت دانلود کتاب Asynchronous Programming in Rust می‌توانید پس از پرداخت، دریافت کنید.