ویرگول
ورودثبت نام
ایمان دیده ور
ایمان دیده ورتوسعه دهنده فرانت اند
ایمان دیده ور
ایمان دیده ور
خواندن ۶ دقیقه·۲ ماه پیش

داستان 3 ماه Refactoring و 60 میلیون پاداش عملکرد

نه یک فیچر جدید لانچ کردیم، نه تکنولوژی عجیب و غریبی اضافه کردیم و نه حتی یک خط کد قابل نمایش به کاربر نهایی تحویل دادیم. فقط نشستیم و تصمیم گرفتیم قبل از اینکه بیشتر جلو برویم، کمی به کدی که نوشته بودیم برگردیم.

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

پروژه‌ای که روی آن کار می‌کردم، از آن پروژه‌هایی بود که بیزینسش را واقعاً دوست داشتم. از شروع پروژه مدتی گذشته بود و هنوز فرصت خوبی برای ساختن یک محصول قابل توسعه داشتیم؛ اما تصمیم‌های اشتباه در ابتدای مسیر باعث شده بود کدها خیلی زود از چیزی که انتظار داشتیم فاصله بگیرند.

در بک‌اند، به‌خاطر انتخاب معماری مناسب، وضعیت قابل کنترل‌تر بود. اما در فرانت‌اند نه خبری از معماری مشخص بود و نه خیلی می‌شد از نظافت کد حرف زد :)

مشکل فقط «کد بد» نبود.

وقتی چند نفر روی یک کدبیس کار می‌کنند، کوچک‌ترین تصمیم یک نفر می‌تواند روی کار نفر بعدی اثر بگذارد. یک تغییر ساده ممکن است یک Side Effect ناخواسته ایجاد کند، یک State را در جای دیگری تغییر دهد یا حتی فیچری را که قبلاً درست کار می‌کرد، خراب کند.

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

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

معماری؛ اول باید بدانیم کجا ایستاده‌ایم

یکی از اولین مشکلات، معماری Frontend بود. Rendering را آگاهانه بین Server و Client تقسیم کردیم.

Componentها درست تفکیک نشده بودند و تقریباً همه چیز به شکل Client-Side پیاده‌سازی شده بود. این موضوع هم ساختار پروژه را پیچیده‌تر کرده بود و هم باعث می‌شد بخش زیادی از منطق و Rendering در سمتی انجام شود که واقعاً نیازی به آن نبود.

بعد از آن، به جای اینکه کل پروژه را Client کنیم، تصمیم گرفتیم فقط جاهایی که واقعاً به Browser API، State یا Interaction کاربر نیاز دارند، Client باشند پس 'use client' دیگر یک انتخاب پیش‌فرض نبود؛ تبدیل شد به چیزی که باید برای استفاده از آن دلیل داشته باشیم و همین تغییر به‌تنهایی باعث شد مرز بین Server و Client در پروژه واضح‌تر شود و Componentها هم مسئولیت مشخص‌تری پیدا کنند.

DRY؛ چرا یک چیز را چند بار بنویسیم؟

در پروژه کدهای تکراری کم نبود.

یک منطق مشابه در چند Feature، یک API Call با چند پیاده‌سازی متفاوت، Component هایی که تقریباً یک کار را انجام می‌دادند و Utilityهایی که هر کدام گوشه‌ای از پروژه دوباره نوشته شده بودند.

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

برای همین شروع کردیم به پیدا کردن الگوهای تکرارشونده و تبدیل آن‌ها به چیزهایی که واقعاً قابلیت استفاده مجدد داشتند؛ از Hook و Utility گرفته تا Component و Plugin.

هدفمان این نبود که به هر قیمتی همه چیز را Abstract کنیم. هدف این بود که هرجا یک منطق واقعاً مشترک وجود دارد، فقط یک منبع برای نگهداری آن داشته باشیم.

TypeScript؛ نصب بودن کافی نیست

یکی از جالب‌ترین قسمت‌های پروژه Typescript بود که نصب شده بود، اما عملاً بیشتر شبیه یک مزاحم بود تا یک ابزار.

any تقریباً در هر جایی که Typescript می‌توانست کمک کند، حضور فعال داشت اما واقعیت این است که صرفاً نصب Typescript هیچ مزیتی برای پروژه ایجاد نمی‌کند. اگر قرار باشد همه چیز any باشد، عملا تمام مزیت Typescript را کنار گذاشته‌ایم.

شروع کردیم به مشخص کردن Typeها.

برای مدل‌های مختلف از interface و type استفاده کردیم، Typeهای ورودی و خروجی توابع و سرویس‌ها را مشخص کردیم و در جاهایی که لازم بود از Utility Typeها کمک گرفتیم.

در نتیجه، وقتی با یک Function یا API کار می‌کردیم، دیگر لازم نبود حدس بزنیم چه چیزی دریافت می‌کند و چه چیزی برمی‌گرداند.

TypeScript کم‌کم از یک چیزی که فقط در پروژه نصب شده بود، تبدیل شد به قراردادی بین بخش‌های مختلف سیستم.

SOLID؛ وقتی هر چیزی یک مسئولیت دارد

بخشی از کدها چندین کار مختلف را در یک Pipeline انجام می‌دادند.

یک Function هم API Call می‌کرد، هم داده را Transform می‌کرد، هم State را تغییر می‌داد و هم تصمیم می‌گرفت UI چه چیزی نمایش دهد و طبیعی بود که تغییر یک قسمت، قسمت‌های دیگر را هم تحت تأثیر قرار دهد.

از طرف دیگر، Featureهایی داشتیم که برای اضافه کردن یک رفتار جدید، مجبور بودیم چندین if دیگر به آن‌ها اضافه کنیم. Dependencyها هم همیشه شفاف نبودند و بعضی Componentها مسئولیت‌هایی بیشتر از چیزی که باید، به دوش می‌کشیدند.

اینجا سعی کردیم اصول SOLID را نه به عنوان یک چک‌لیست، بلکه به عنوان یک راهنمای طراحی وارد پروژه کنیم.

Functionها و Componentها را تا جای ممکن تک‌مسئولیتی کردیم. وابستگی‌ها را واضح‌تر کردیم و سعی کردیم برای توسعه Featureهای جدید، کمتر مجبور به دستکاری کدهای قبلی باشیم.

قرار نبود همه چیز را به کلاس و Interface تبدیل کنیم یا برای یک Component ساده، معماری Enterprise بسازیم.

هدف این بود که کدی بنویسیم که تغییر دادنش دردسر کمتری داشته باشد.

Performance؛ هر Re-render بد نیست، ولی هر Re-render هم لازم نیست

Performance هم یکی از مشکلات جدی پروژه بود.

Re-render ذاتاً مشکل نیست؛ مشکل زمانی شروع می‌شود که Renderهای غیرضروری یا زنجیره‌ای، هزینه‌ی اضافی ایجاد کنند. React برای همین قابلیت رندر مجدد ساخته شده است و این مشکل زمانی شروع می‌شود که Re-renderهای غیرضروری، زنجیره‌ای از محاسبات و درخواست‌های اضافه ایجاد کنند.

در پروژه، استفاده نادرست از Hookها باعث شده بود بعضی Componentها بیشتر از چیزی که لازم بود Render شوند. در بعضی موارد همین اتفاق باعث API Callهای غیرضروری می‌شد و حتی گاهی تعداد درخواست‌ها آن‌قدر بالا می‌رفت که با Rate Limit مواجه می‌شدیم.

شروع کردیم به بررسی دقیق‌تر Dependencyهای Effectها، Lifecycle کامپوننت‌ها، نحوه مدیریت State و در جاهایی که واقعاً لازم بود از useCallback و useMemo استفاده کردیم؛ نه صرفاً برای اینکه اسمشان در پروژه باشد.

برای درخواست‌ها هم سراغ راهکارهایی مثل Cache و Throttling رفتیم تا هر Interaction کاربر الزاماً به یک درخواست جدید منجر نشود.

Performance برای ما دیگر «هرچه کمتر Render شود بهتر است» نبود.

یاد گرفتیم که باید بفهمیم چرا یک Component دوباره Render می‌شود و آیا این Render واقعاً لازم است یا نه.

فقط Clean Code نبود

در نهایت، چیزی که تغییر کرد فقط ظاهر کدها نبود و ما یک‌سری قانون برای خودمان ساختیم.

قبل از اضافه کردن یک Component جدید، فکر می‌کردیم آیا چیزی مشابه آن وجود دارد؟

قبل از استفاده از any، سؤال می‌کردیم آیا واقعاً نمی‌توان Type دقیق‌تری تعریف کرد؟

قبل از Client کردن یک Component، بررسی می‌کردیم آیا واقعاً به Client نیاز دارد؟

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

بعد از افزایش سرعت و کیفیت توسعه فیچر‌ها، کاهش محسوس مشکلات در رفت و برگشت های پن‌تست و ... مدیریت مجموعه هر یک از اعضای تیم فرانت 60 میلیون تومان پاداش عملکرد اعطا کردند و این تجربه از Refactoring تبدیل شد به یکی از شیرین ترین تجربیات نظافت پروژه در تمام تجربیات کاری‌ام.

برای من Clean Code بعد از این تجربه دیگر به معنی کدی نبود که وقتی بازش می‌کنیم، همه چیز مرتب و زیبا به نظر برسد بلکه به موقعیتی رسیدیم که سه ماه بعد یک Feature جدید به پروژه اضافه میشد، مجبور نبودیم از ترس خراب شدن قسمت‌های دیگر، دست به کد نزنیم.

یعنی یک Developer جدید بتواند ساختار پروژه را بفهمد و یعنی وقتی یک نفر چیزی را تغییر می‌دهد، نفر بعدی مجبور نباشد تمام پروژه را برای پیدا کردن Side Effect های احتمالی بررسی کند.

شاید مهم‌تر از همه، بعد از این‌ بتوانیم با خیال راحت بگوییم:

«این قسمت را تغییر می‌دهم و می‌دانم چه اتفاقی قرار است بیفتد.»

بهترین روز کاری من همان روزی بود که تصمیم گرفتیم کدها را تمیز کنیم. چون آن روز، در واقع فقط کدها را تمیز نکردیم؛

داشتیم هزینه‌ی آینده‌ی پروژه را کمتر می‌کردیم.

clean codeپروژهاصول solidتجربیات کاری
۰
۰
ایمان دیده ور
ایمان دیده ور
توسعه دهنده فرانت اند
شاید از این پست‌ها خوشتان بیاید