ویرگول
ورودثبت نام
Farhad Shekari
Farhad Shekari
Farhad Shekari
Farhad Shekari
خواندن ۶ دقیقه·۴ ماه پیش

مرزها، چگونه جلوی غیر قابل تغییر بودن را بگیریم!؟

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

1.تشخیصِ اشتباه: اکثراً فکر می‌کنند مسئله «طول کد» است:

اولین چیزی که همه می‌بینند: «آخ جون یک سرویسِ ۵۰۰ خطی، بشکنیمش.» این وسوسه‌ی درست، با دلیلِ غلط است. اگر مسئله واقعاً طول کد بود، Extract Method مسئله را حل می‌کرد و امروز مقاله‌ای برای ارائه خدمت شما نداشتم.
مسئله دو چیزِ کاملاً متفاوت بود:

اول، Coupling پنهان. سرویس (به عنوان یک Orchestrator) بیش از بیست اینترفیس تزریق می‌کرد و چون جواب نگرفته بود هنوز :) از Service Locator هم استفاده می‌کرد. تأثیرِ واقعیِ این کار روی طولِ کد نبود؛ روی نگهداری و مهم‌تر از آن زمانِ کشفِ خطا بود. با Service Locator، وابستگی از compile-time به run-time منتقل می‌شود. یعنی گرافِ وابستگی دیگر در امضای سازنده دیده نمی‌شود — در دلِ متدها پنهان است و فقط وقتی خودش را نشان می‌دهد که در production منفجر شود. این «couplingی» است که compiler دیگر پشتِ ما نیست .

دوم، کج‌فهمیِ بیزنسی. هیچ یک جایی وجود نداشت که بگوید «قاعده‌ی ثبت/ویرایشِ فلان موجودیت اینجا زندگی می‌کند». قاعده در پنج نقطه پخش شده بود. این یعنی هر تغییرِ بیزنسی به یک عملیاتِ باستان‌شناسی تبدیل می‌شد و باید با قلم مو و ذره‌بین بیفتیم دنبال خطا.

یک مسئله‌ی دیگه هم اینکه این Orchesrator به‌حدی DI وارد خودش کرده بود که دچار چاقی مفرط شده بود(این در کنار اون دوتای دیگه خیلی عددی به حساب نمی‌آید)

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

۲. Pipeline در برابر Chain of Responsibility: انتخابِ معنایی، نه سلیقه‌ای

وقتی می‌خواستم فرآیندِ ثبت/ویرایش را مدل کنم، دو گزینه‌ی به‌ظاهر مشابه روی میز بود و اکثر بحث‌ها هم دقیقاً همین‌جا سطحی می‌شوند: «Chain of Responsibility ش کنم چون قشنگه.»

اما این دو الگو یک تفاوتِ معنایی دارند، نه ساختاری:

  • Chain of Responsibility یک disjunction(انفصال) است: یک انتخاب‌گر. هر handler می‌تواند بگوید «این مالِ من است» و زنجیره را قطع کند. مدلِ ذهنی‌اش «کدام‌یک؟» است.

  • Pipeline یک conjunction(اتصال) است: یک ترکیبِ ترتیبی. هر مرحله اجرا می‌شود، خروجی را غنی‌تر می‌کند و به بعدی می‌دهد. مدلِ ذهنی‌اش «همه، به‌ترتیب» است.

دامنه‌ی ما انباشتی(accumulative) بود: اعتبارسنجی، سپس غنی‌سازی، سپس اعمالِ قاعده، سپس persist. هیچ مرحله‌ای نمی‌خواست بقیه را «رد» کند؛ هر مرحله روی دوشِ مرحله‌ی قبل می‌ایستاد. این دقیقاً conjunction است. اگر اینجا CoR می‌زدیم، یک semanticِ «انتخاب» را به یک فرآیندِ «انباشت» تحمیل کرده بودیم و شش ماهِ دیگه اگر کسی می‌پرسید «چرا این handler گاهی زنجیره را قطع می‌کند؟» — و جواب می‌شد «نمی‌دانیم، ولی اگر برش داری خراب می‌شود.»

درسِ معماری اینجا این است: الگو را از رویِ شکلِ کد انتخاب نکن، از رویِ معنایِ دامنه انتخاب کن(Eric Evans). Pipeline و CoR روی وایت‌برد شبیه‌اند؛ در قراردادِ رفتاری، دو موجود متفاوت‌.

۳. Lifetime، که در واقع یک تصمیمِ Correctness بود

اینجا جایی است که باید خیلی حواس‌جمع این موضوع باشیم که فقط تصمیم performance نگیریم، بلکه باید یک تصمیمِ corectness بگیریم(خیلی از مواقع، تصمیمِ پرفورمنسی ما را به جایی می‌برد که روی production فقط معنی‌ش را با گوشت و پوست و جاهای دیگه‌مون حس می‌کنیم).

برای lifetime، سه راه روی میز بود:

  • Singleton: وسوسه‌انگیز از نظر GC، اما در این نقطه یک بمب بود. componentهای ما state داشتند(موضوعی که در خارج از context این بخش می‌شد، خیلی مواقع باید حواسمون به این موضوع هم باشه که حد یقف قائل بشیم برای کارمون) و به‌ازای هر request باید ایزوله می‌ماندند. Singleton یعنی state leak بینِ requestها و race condition — یعنی یک باگِ correctness که در تست‌های تک‌کاربره هیچ‌وقت خودش را نشان نمی‌دهد و فقط زیرِ load ظاهر می‌شود.

  • Transient خالص: درست، اما هزینه‌اش فشارِ بی‌مورد روی GC بود؛ به‌ازای هر مرحله یک allocation.

  • اینکه Scoped باشیم، این مسئله در جهانی که پروژه‌ی ما زندگی میکنه و توضیحش طولانی هست، بصورت Hybrid (per-request در وب، per-thread در worker) معنی داره: مرزِ ایزولاسیون را دقیقاً منطبق میکنه بر مرزِ منطقیِ UoW: در وب، مرز = request. در پردازشِ background، مرز = thread.

نکته‌ای که همیشه مد نظرم هست در این زمینه این هست که : lifetime چیزی جز ترسیمِ مرزِ به‌اشتراک‌گذاریِ state نیست. وقتی lifetime را به‌عنوان تصمیمِ perf می‌بینی، Singleton را انتخاب می‌کنی چون «سریع‌تر است». وقتی به‌عنوان تصمیمِ correctness (صحت سنجی) می‌بینی، اول می‌پرسی «مرزِ ایزولاسیونِ درست کجاست؟» و بعد ارزان‌ترین گزینه‌ای را که آن مرز را نقض نمی‌کند برمی‌داری.

۴. بدهیِ فنیِ آگاهانه: چرا UoW صریح را نگذاشتم

بالغ‌ترین تصمیمِ این پروژه، کاری بود که نکردم.

یک Unit of Work صریح، از نظر آکادمیک، اینجا جای درستش بود. اما زیرساختِ legacy طوری بود که واردکردنِ یک UoW صریح ریسکِ بالایی روی مرزِ تراکنش تحمیل می‌کرد — همان‌جایی که کوچک‌ترین اشتباه به data corruption ختم می‌شود.

پس یک تصمیمِ صریح گرفتم: نبودِ UoW صریح را به‌عنوان بدهیِ آگاهانه پذیرفتم و در Backlog شخصی آوردم. اینکار با «فراموش‌کردن» فرق دارد. بدهیِ فنیِ سالم آن است که در ترازنامه ثبت شده باشد و بدانی چه‌وقت و با چه هزینه‌ای بازپرداختش می‌کنی. بدهیِ فنیِ سمی آن است که کشفش کنی وقتی موعدِ پرداختش رسیده(این هم برای عمو باب هست فکر کنم).

این اصل هم خیلی مهمه: معماری همیشه انتخابِ «بهترین» نیست؛ اغلب انتخابِ «بهترینِ ممکن با ریسکِ قابلِ‌قبول» است، به‌شرطی که این انتخاب مستند و برگشت‌پذیر باشد(این هم از برادر بزرگترمون فاولر هست).

۵. Rich Domain، به مقدار لازم

آسان بود که کلِ سیستم را Rich Domain معرفی کنم و در معرفی‌ها بگم «پروژه‌ی ما DDD خالص هست». اما این خالی‌بندی بود، خودمم می‌دونستم که دارم راست نمی‌گم.

Rich Domain را فقط در کلاس Context حمل کننده ی دیتا اعمال کردم — همان جایی که نرخِ تغییرِ قواعد بالا بود، چرا چون اونجا هست که همه عملا دارن میبیننش و باید کنترل میشد. بقیه‌ی بخش‌ها Orchestration ماندند.

یک اصل دیگه هم داریم Rich Domain را آن‌جا خرج کن که تغییر زندگی می‌کند. این جمله ی معروف رو به یاد بیاریم که : یک موجودیتِ anemic در ناحیه‌ای که سالی یک‌بار عوض می‌شود، مشکلِ کسی نیست. یک موجودیتِ anemic در قلبِ قواعدِ بیزنسیِ پرتغییر، بدهیِ فردایِ توست.

نتیجه:

هدفم از انتشار این مطلب بیشتر این بود که در یک ریفکتور اصولی چطوری تصمیم گیری میکنم، تا چه حد عمیق میشم و اینکه نظراتی را از شما بشنوم که به جنبه های دیگری از مسئله فکر کنیم باهم.
مهم‌ترین نکته‌ای که بعنوان یک دولوپر درون یک تیم این کار رو انجام دادم و مستندش کردم این بود که هزینه‌ی جرأتِ تغییر را همه‌مان در خروجی‌هایمان سعی کنیم پایین بیاوریم. این‌که آیا یک developer برای عوض‌کردنِ یک قاعده، با اطمینان دست به کد می‌برد، یا با ترس آن‌را دور می‌زند. این هزینه را از «هیچ‌کس جرأت نمی‌کند» به «هرکس با اطمینان تغییر می‌دهد» خواهد رساند. و این تنها متریکی است که بعداً اهمیت خود را در نگهداری و دیباگ احتمالی سیستم نشان می‌دهد.

software architecturedesign patternrefactoring
۰
۰
Farhad Shekari
Farhad Shekari
شاید از این پست‌ها خوشتان بیاید