ویرگول
ورودثبت نام
مسعود شریفی پور
مسعود شریفی پورmasoudsharifipour.ir
مسعود شریفی پور
مسعود شریفی پور
خواندن ۱۴ دقیقه·۳ ماه پیش

آیا Engineering Manager باید هنوز کد بزند؟

من هنوز کد زدن رو دوست دارم. خیلی زیاد.

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

IDE رو باز کنم، یه پروژه رو بالا بیارم، چند تا فایل رو بررسی کنم، بفهمم مشکل کجاست، کد بزنم و یه Pull Request باز کنم.

اون حس خوبی که آخرش با خودت میگی:

«خب، اینو خودم درست کردم.»

برای کسی که سال‌ها مهندس نرم‌افزار بوده، این حس خیلی آشناست. (تعریف از خودم نباشه 😁)

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

اما هرچی بیشتر درگیر کارم به عنوان Engineering Manager شدم، بیشتر به این سؤال فکر کردم:

آیا من هنوز باید کد بزنم؟

و هرچی بیشتر بهش فکر می‌کنم، به نظرم سؤال درست این نیست.

سؤال درست اینه:

«من چرا دارم کد می‌زنم؟»

وقتی Software Engineer بودم

وقتی Software Engineer بودم، کدنویسی کار اصلی من بود.

قبلاً اگر ازم می‌پرسیدی:

«امروز چیکار کردی؟»

جواب خیلی راحت بود:

کد زدم، Feature ساختم، Bug حل کردم، Code Review کردم، یه سیستم رو تغییر دادم.

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

اما وقتی مسیر Engineering Manager رو پیش می‌گیری، بازی عوض میشه.

دیگه قرار نیست ارزش تو با تعداد Featureهایی که خودت تحویل دادی سنجیده بشه.

قرارِ تیمی که باهاش کار می‌کنی بهتر کار کنه.

بچه‌های تیم باید رشد کنن.

تصمیم‌های فنی بهتری گرفته بشه.

مشکلات زودتر دیده بشن.

و تیم بتونه بدون اینکه برای هر تصمیمی بیاد سراغ تو، کارش رو جلو ببره.

این تغییر برای من یکی از سخت‌ترین بخش‌های Manager شدن بوده.

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


کدنویسی برای اینکه فقط Feature تحویل بدی

این قسمت به نظرم جای خطرناک ماجراست.

نه اینکه همیشه بد باشه، ولی خیلی راحت میتونه تبدیل بشه به یه عادت بد.

فرض کنیم یکی از مهندس‌های تیم مرخصی رفته و یه Feature نیمه‌کاره مونده.

منم می‌دونم این Feature چطوری باید پیاده بشه.

خب طبیعیه که با خودم بگم:

«بذار خودم جمعش کنم.»

یا مثلاً یه مشکل فنی داریم که مدت‌هاست کسی وقت نکرده بره سراغش.

منم وقت دارم.

میشینم پاش، کدش رو می‌نویسم، PR می‌زنم.

حس خوبی هم داره.

ولی یه سؤال مهم وجود داره:

آیا این واقعاً بهترین استفاده از وقت من بوده؟

خیلی وقت‌ها جوابش «نه» است.

چون من EM هستم و هفته‌ام اصلاً قابل پیش‌بینی نیست.

ممکنه دو ساعت وقت برای یه کار کنار گذاشته باشم، ولی وسطش یه Incident اتفاق بیفته، یه مصاحبه داشته باشم، یه 1:1 جدی پیش بیاد، محصول یه موضوع فوری داشته باشه، مدیرم یه کار فوری بخواد یا یه Escalation از سمت مشتری برسه.

حالا من یه PR ساخته‌ام که باید جلو بره.

Commentها باید جواب داده بشن.

Review باید انجام بشه.

PR باید Merge بشه.

ولی من دیگه وقت ندارم.

در نتیجه چیزی که قرار بود کمک کنه، خودش تبدیل میشه به یه Dependency.

و این دقیقاً چیزیه که یه EM نباید درگیرش بشه.

البته اینجا هم مثل خیلی چیزهای دیگه، یه جواب قطعی وجود نداره.

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

اتفاقاً اینکه بتونی همین شرایط رو ببینی و تشخیص بدی الان باید خودم وارد بشم یا نه، خودش یکی از Skillهای مهم یه EMـه.


ممکنه جلوی رشد تیم رو هم بگیری

این قسمت رو خودم خیلی جدی می‌گیرم.

گاهی یه کاری رو برمی‌دارم چون می‌دونم خودم سریع‌تر انجامش میدم.

مثلاً کاری که برای من دو ساعت زمان می‌بره، شاید برای یکی از بچه‌های تیم یه روز کامل طول بکشه.

طبیعیه که مغزم بگه:

«خب خودت انجامش بده دیگه، چرا وقت تیم رو می‌گیری؟»

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

چون توی اون یه روز یه چیزی یاد می‌گیره که بعداً می‌تونه خودش انجامش بده.

این یکی از سخت‌ترین تغییرات ذهنی برای Manager شدنه:

همیشه سریع‌ترین آدم برای انجام یه کار، بهترین آدم برای انجام اون کار نیست.

گاهی بهترین کاری که من می‌تونم انجام بدم اینه که کاری رو که خودم بلدم، به یکی دیگه یاد بدم تا خودش انجامش بده.

حتی اگر بدونم احتمالاً اولش خراب‌کاری هم می‌کنه.

بخشی از کار من دیگه فقط حل کردن مسئله نیست.

ساختن آدم‌هاییه که بتونن مسئله رو حل کنن.


یه خاطره بگم

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

یه Feature داشتیم که توی Planning به یکی از بچه‌های تیم داده شد.

تازه وارد تیم شده بود و هنوز خیلی با سیستم آشنا نبود، ولی چیزی که ازش دوست داشتم، پشتکار و انگیزه‌اش بود.

خودم هم در جذبش نقش داشتم و از همون اول حس خوبی نسبت بهش داشتم.

وقتی Feature رو بهش دادیم، اوایل کار کنارش بودم.

کمکش کردم مسئله رو تحلیل کنه، Dependencyها رو بشناسه، بفهمه از کجا باید شروع کنه و چه مسیری رو برای پیاده‌سازی بره.

ولی یه جایی عمداً رهاش کردم.

نه اینکه دیگه برام مهم نباشه.

اتفاقاً برعکس.

بهش اعتماد کرده بودم.

می‌خواستم خودش مسیر رو پیدا کنه.

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

Feature پیاده شد و رفت برای تست.

QA هم تستش کرد و همه‌چیز ظاهراً درست بود.

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

سناریو این بود که مثلاً من به عنوان کارشناس فروش، برای یه مشتری یه لینک پرداخت می‌فرستم.

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

قرار بود اعتبار حساب مشتری شارژ بشه.

ولی چیزی که اتفاق می‌افتاد این بود که اعتبار حساب کارشناس فروش که لینک رو ساخته و فرستاده بود، شارژ می‌شد!

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

طبیعتاً باگ مهمی بود.

اینجا هم می‌تونستم خیلی راحت وارد بشم و بگم:

«خب، این Feature رو من درست می‌کنم.»

یا حتی بدتر:

«چطور همچین چیزی رو ندیدی؟»

ولی واقعاً هیچ‌کدوم اینا کمکی به رشد اون آدم نمی‌کرد.

پس دوباره سعی کردم کنارش باشم، ولی نه اینکه مسئله رو براش حل کنم.

کمکش کردم مسئله رو درست بفهمه، سؤال‌های درست ازش پرسیدم و گذاشتم خودش مسیر پیدا کردن مشکل رو بره.

خیلی سریع متوجه شد مشکل کجاست.

Fix رو انجام داد.

تست شد و موضوع حل شد.

اینجا یه نکته برای خودم خیلی مهم بود.

من به این آدم اعتماد کرده بودم.

حالا قرار نبود با اولین اشتباه، اون اعتماد رو پس بگیرم.

اشتباه اتفاق افتاده بود.

Feedback لازم هم بهش داده شد.

مشخص شد چه چیزی باید بهتر می‌شد، مخصوصاً توی تحلیل سناریوها و تست کردن حالت‌های مختلف.

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

اتفاقاً برعکس.

سعی کردم همچنان پاش بایستم.

و نتیجه خیلی جالب بود.

بعد از اون اتفاق، برای این آدم یه مسیر رشد جدی شروع شد.

کم‌کم مسئولیت‌های بیشتری گرفت، اعتمادبه‌نفسش بیشتر شد، سیستم رو بهتر شناخت و در نهایت تبدیل شد به یکی از بهترین Engineerهای تیم.

اگر اون روز من Feature رو ازش گرفته بودم، احتمالاً باگ هم سریع‌تر حل می‌شد.

ولی شاید یه چیز مهم‌تر رو از دست می‌دادیم:

فرصت رشد یه آدم.

این برای من یکی از مهم‌ترین تفاوت‌های Engineer بودن و Engineering Manager بود.

وقتی Engineer هستی، طبیعیه که تمرکزت روی حل کردن مسئله باشه.

ولی وقتی Manager میشی، باید کم‌کم یاد بگیری که همیشه قرار نیست خودت مسئله رو حل کنی.

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

حتی اگر احتمال داشته باشه اشتباه کنه.

حتی اگر خودت بتونی سریع‌تر انجامش بدی.

چون هدف فقط این نیست که این Feature امروز درست بشه.

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


پس یعنی مدیر نباید کد بزنه؟

نه، اصلاً.

به نظرم اینم یکی دیگه از اون جواب‌های صفر و یکیه که برای این موضوع زیاد می‌بینیم.

من اگر EM هستم، هنوز باید فنی بمونم.

باید بفهمم سیستم چطوری کار میکنه.

باید بدونم تیم با چه مشکلاتی درگیره.

باید بتونم درباره Architecture، Performance، Reliability، Deployment و Technical Debt حرف بزنم.

اگر یکی از بچه‌های تیم بگه:

«این تغییر خیلی ساده نیست.»

نباید فقط بگم:

«خب چند روز زمان می‌خواد؟»

باید بتونم بفهمم چرا ساده نیست.

اگر Deploymentها ۴۰ دقیقه طول میکشن و هر چند وقت یه بار هم Fail میشن، برای من مهمه بفهمم مشکل کجاست.

اگر یه تست مدام Flaky میشه، خوبه که بدونم چرا.

اگر تیم از یه Service خاص متنفره، باید بدونم چرا.

برای همین من فکر می‌کنم EM باید داخل کد باشه، ولی لزوماً کدنویس اصلی تیم نباشه.


کدنویسی برای فهمیدن با کدنویسی برای تحویل دادن فرق داره

این بخش برای من خیلی جذابه.

گاهی لازم نیست یه Feature کامل بسازم.

میتونم یه Bug رو Debug کنم.

میتونم Pipeline مربوط به Deployment رو بررسی کنم.

میتونم یه Service رو که خوب نمی‌شناسم از روی کد بخونم.

میتونم با یکی از بچه‌ها Pair بشم.

میتونم برم ببینم چرا یه تست خاص مدام Fail میشه.

حتی میتونم یه تغییر کوچیک بدم که قرار نیست هیچ‌کس براش Sprint Planning داشته باشه.

هدف اینجا تحویل Feature نیست.

هدف Understandingـه.

میخوام اونقدر نزدیک به سیستم بمونم که وقتی تیم درباره یه Technical Constraint، یه تخمین، یه Trade-off یا یه مشکل معماری صحبت میکنه، واقعاً بفهمم چی میگن.

نه اینکه فقط سرم رو تکون بدم و بگم:

«بله، بله، Technical Debt.»

این به نظرم یکی از خطرناک‌ترین حالت‌های EM شدنه.

مدیری که دیگه واقعاً Engineering رو نمی‌فهمه، ولی همچنان درباره Engineering تصمیم می‌گیره.


AI این داستان رو یه مقدار تغییر داده

تا چند وقت پیش، یکی از مشکلات اصلی این بود که کدنویسی جدی Focus می‌خواست.

اگر قرار بود واقعاً یه چیزی بسازم، باید چند ساعت وقت خالی داشتم.

برای EM این تقریباً یه شوخیه.

چون ممکنه ساعت ۹ صبح برنامه داشته باشم که روی یه موضوع فنی کار کنم و ساعت ۹:۱۵ اولین جلسه برنامه‌ریزی‌نشده‌ام شروع بشه!

ولی AI یه مقدار این قضیه رو تغییر داده.

الان میتونم یه Agent رو بفرستم دنبال یه موضوع.

مثلاً:

«برو بررسی کن چرا Deployment ما اینقدر طول میکشه.»

بعد خودم برم سراغ یه جلسه.

بین دو جلسه نتیجه رو ببینم.

به Agent جهت بدم.

بعد بذارم Implementation اولیه رو انجام بده.

و در نهایت خودم Review کنم.

این به نظرم یه استفاده خیلی خوب از AI برای EMـه.

چون میتونم برم سراغ چیزهایی که تیم شاید مدت‌هاست میخواد انجام بده، ولی هیچ‌وقت واقعاً توی اولویت قرار نمی‌گیره.

مثلاً بررسی Technical Debt، بهبود Observability، بررسی Pipeline، یه Flaky Test یا حتی فهمیدن اینکه یه Service قدیمی دقیقاً چه کاری انجام میده.


ولی AI یه مشکل جدید هم آورده

AI خیلی راحت‌تر از قبل بهم اجازه میده مفید باشم.

ولی یه مشکل وجود داره:

خیلی راحت‌تر هم میتونم فکر کنم مفیدم، در حالی که دارم مزاحم تیم میشم.

این دوتا با هم فرق دارن.

فرض کن تیم داره روی یه Feature کار میکنه.

منم با Claude چند ساعت کار میکنم و یه PR آماده میکنم.

کلی کد تولید شده.

تست هم نوشته شده.

PR هم مرتب و تمیزه.

از بیرون همه‌چیز عالیه.

ولی شاید اصلاً نباید من این کار رو انجام میدادم.

شاید یکی از Engineerهای تیم باید این کار رو انجام میداد.

شاید دارم یه تصمیم فنی رو از تیم می‌گیرم.

شاید فردا تیم باید ساعت‌ها وقت بذاره تا بفهمه من چی ساختم.

یا بدتر:

شاید خودم تبدیل شدم به Critical Path.


برای تصمیم گرفتن سه تا سؤال دارم

برای همین اخیراً اگر بخوام یه کار فنی رو خودم بردارم، سعی میکنم سه تا سؤال از خودم بپرسم.

۱. اگر من انجامش ندم، یکی از بچه‌های تیم خودش سراغش میره؟

اگر جواب بله باشه، احتمالاً بهتره خودم انجامش ندم.

چون اگر یکی از Engineerهای تیم بالاخره وقت پیدا میکنه و میره سراغش، چرا باید فرصت رو ازش بگیرم؟

ولی اگر جواب اینه که:

«نه، احتمالاً هیچ‌وقت انجام نمیشه، چون همیشه چیزهای مهم‌تری داریم.»

اون وقت قضیه فرق میکنه.

مثلاً یه Technical Debt قدیمی که همه میدونن باید حل بشه، ولی هیچ‌وقت توی اولویت قرار نمی‌گیره.

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


۲. اگر وسط کار متوقف بشم، مشکلی پیش میاد؟

این سؤال خیلی مهمه.

من واقعاً نباید خودم رو بذارم روی Critical Path.

چون احتمال اینکه برنامه‌ام به هم بخوره خیلی زیاده.

ممکنه امروز فکر کنم سه ساعت وقت دارم، ولی یهو یه Incident بیاد.

یا یه جلسه اضطراری پیش بیاد.

یا یه موضوع مدیریتی مهم اتفاق بیفته.

اگر کاری که برداشتم بدون من متوقف میشه، احتمالاً انتخاب خوبی نبوده.


۳. آیا این کار میتونه برای یکی از مهندس‌های تیم یه فرصت یادگیری باشه؟

این یکی یه مقدار سخت‌تره.

چون همیشه از قبل نمیشه فهمید.

ولی باید حواسم باشه که یکی از مهم‌ترین مسئولیت‌های من، رشد دادن آدم‌های تیمه.

اگر هر کار جالبی رو خودم بردارم، عملاً دارم فرصت‌های یادگیری رو از بچه‌ها می‌گیرم.

ممکنه توی کوتاه‌مدت تیم سریع‌تر کار کنه.

ولی توی بلندمدت چی؟

ممکنه یه تیم داشته باشم که کلی کار تحویل داده، ولی آدم‌هاش رشد نکردن.

به نظرم این معامله خوبی نیست.


من فکر میکنم باید برای کدنویسی وقت مشخص داشته باشم

با همه این حرف‌ها، اینکه EM کلاً کدنویسی رو کنار بذاره هم به نظرم اشتباهه.

خودم دوست دارم چند ساعت در هفته رو عمداً برای کار فنی کنار بذارم.

نه برای اینکه دوباره Developer بشم.

برای اینکه Technical بمونم.

حتی یه لیست از چیزهایی که درست نمی‌فهمم هم میتونه خیلی کمک کنه.

هر وقت وسط یه بحث فنی متوجه شدم دارم سر تکون میدم ولی واقعاً نمیفهمم طرف مقابل چی میگه، اون موضوع باید بره توی لیستم.

بعداً میرم سراغش.

مثلاً اخیراً اگر بخوام عمیق‌تر روی موضوعاتی مثل ، Observability یا ابزارهایی مثل NER (Named-entity recognition) کار کنم، اتفاقاً AI کمک خیلی بزرگیه.

میتونم یه موضوع رو بردارم و از چند زاویه بررسیش کنم.

سؤال بپرسم.

مثال بخوام.

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

این به نظرم خیلی ارزشمنده.


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

فکر میکنم این مهم‌ترین قسمت کل ماجراست.

من قرار نیست دوباره برگردم به همون Software Engineer چند سال پیش.

قرار نیست بیشترین کد تیم رو من بنویسم.

قرار نیست بهترین Technical Decisionها حتماً از من بیاد.

قرار نیست هر PR مهمی رو خودم باز کنم.

هدف چیز دیگه‌ایه.

میخوام اونقدر فنی بمونم که وقتی تیم درباره یه مشکل حرف میزنه، بفهمم مشکل چیه.

وقتی یکی یه تخمین میده، بتونم سؤال درست بپرسم.

وقتی دو تا راه‌حل فنی داریم، بتونم Trade-offهاشون رو بفهمم.

وقتی تیم میگه:

«این کار سه روزه نیست.»

بتونم بفهمم چرا.

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


هر خط کدی که نمیفهمی، یه بدهیه

یه جمله‌ای هست که خیلی دوستش دارم:

هر خط کدی که نمیفهمی، یه بدهیه که بالاخره باید با سودش پس بدی.

به نظرم این برای Managerها حتی مهم‌تره.

لازم نیست همه کد رو بفهمم.

واقعاً هم نمیشه.

ولی اگر قسمت‌های مهم سیستم رو نفهمم، دیر یا زود این ناآگاهی خودش رو نشون میده.

یه روز تیم درباره یه مشکل حرف میزنه و من نمیفهمم.

یه روز یه تصمیم معماری گرفته میشه و من نمیتونم درست Challenge کنم.

یه روز یه تخمین اشتباه داده میشه و من نمی‌تونم تشخیص بدم.

اون موقع هزینه فاصله گرفتنم از Engineering رو پرداخت میکنم.


پس بالاخره EM باید کد بزنه یا نه؟

اگر بخوام خیلی کوتاه جواب بدم:

بله.

ولی نه برای اینکه ثابت کنه هنوز Engineerه.

کد بزن برای اینکه بفهمی.

Debug کن برای اینکه سیستم رو بهتر بشناسی.

Pair کن تا با تیم نزدیک بمونی.

روی Technical Debtهایی کار کن که هیچ‌کس وقت رسیدگی بهشون رو نداره.

با AI تحقیق کن.

کد بخون.

سیستم رو بشناس.

ولی حواست باشه خودت رو تبدیل به Developer اصلی تیم نکنی.

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

ممکنه فقط نشونه این باشه که هنوز نتونستی از نقش قبلیت دل بکنی.

من هنوز وقتی یه مسئله فنی جالب میبینم، دلم میخواد خودم برم سراغش.

احتمالاً این حس هیچ‌وقت کامل از بین نمیره.

ولی الان قبل از اینکه دست به کد بشم، سعی میکنم یه سؤال از خودم بپرسم:

«این کاری که الان میخوام انجام بدم، واقعاً به تیم کمک میکنه، یا فقط خودم رو خوشحال میکنه؟»

به نظرم برای یه Engineering Manager، جواب همین سؤال خیلی چیزها رو مشخص میکنه.

شاید وقتی Engineer بودم، موفقیت برای من این بود که خودم مسئله رو حل کنم.

ولی امروز، بخش مهم‌تری از موفقیت برای من اینه که آدم‌هایی داشته باشم که خودشون بتونن مسئله رو حل کنن.

و فکر میکنم این یکی از بزرگ‌ترین تفاوت‌های Engineer بودن و Engineering Manager بودنه.

حرف آخر

و . . . و. . . و… 😄

یکم از این نوشته‌هایی که تایتل‌وار و خط‌به‌خط نوشته شدن فاصله بگیریم.

بعضی قسمت‌های این مقاله رو سعی کردم فنی بنویسم، بعضی جاها عامیانه‌تر حرف زدم، بعضی جاها هم شاید یکم کتابی شده باشه. در واقع چیزی بوده که توی ذهنم بوده و سعی کردم همون رو تبدیل کنم به کلمه و با شما به اشتراک بذارم.

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

ولی اگر بخوام همه این مقاله رو توی یک چیز خلاصه کنم، برای من اینه:

به نظرم یکی از مهم‌ترین مهارت‌های یک EM اینه که بتونه ۳۶۰ درجه به ماجرا نگاه کنه.

فقط تیم خودش رو نبینه.

بتونه تیمش رو ببینه، Stakeholderهاش رو ببینه، بیزینس رو ببینه، Customer رو ببینه و حتی جایی که داره سرویس می‌ده و تأثیری که تصمیم‌هاش اونجا می‌ذاره رو هم ببینه.

باید بتونی وقتی یک تصمیم جلوت قرار می‌گیره، خیلی سریع بفهمی این تصمیم چه اثری روی تیمت داره، روی این Stakeholder چه اثری داره، روی اون یکی Stakeholder چی، روی Customer چه تأثیری می‌ذاره و اصلاً آیا داری یک مانع رو از سر راه تیم برمی‌داری یا خودت داری یک مانع جدید درست می‌کنی.

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

نمی‌تونی از Engineering فاصله بگیری و انتظار داشته باشی همچنان بتونی درباره Engineering تصمیم‌های درست بگیری.

پس آیا EM باید کد بزنه؟

به نظرم آره. چرا که نه؟

چرا نباید کد بزنه؟

فقط باید حواسش باشه که برای چی داره کد می‌زنه.

قرار نیست با کدنویسی ثابت کنیم هنوز Engineer هستیم.

قرار نیست جای بچه‌های تیم رو بگیریم.

قرار نیست همه Featureها رو خودمون بزنیم.

گاهی باید کد بزنیم تا سیستم رو بهتر بفهمیم، گاهی Debug کنیم، گاهی Pair بشیم، گاهی یک Technical Debt قدیمی رو جمع کنیم و گاهی هم با AI بریم سراغ چیزهایی که مدت‌هاست می‌دونیم باید بفهمیم یا درستشون کنیم.

این مقاله برای من خلاصه‌ای بود از کلی مقاله و نوشته‌ای که خوندم، چیزهایی که توی مسیر Engineering Manager شدن یاد گرفتم، تجربه‌هایی که داشتم و البته یک‌سری حس و فکر شخصی که مدت‌ها توی ذهنم بود.

دوست داشتم همه این‌ها رو یک‌جا با شما به اشتراک بذارم.

امیدوارم دوستش داشته باشید. ❤️

تعهدبرنامه نویسیمدیریت
۰
۰
مسعود شریفی پور
مسعود شریفی پور
masoudsharifipour.ir
شاید از این پست‌ها خوشتان بیاید