Coding Beaver
Coding Beaver Blog

Coding Beaver Blog

ทำงานคนเดียว Vs. ทำงานเป็นทีม

Photo by Marvin Meyer on Unsplash

ทำงานคนเดียว Vs. ทำงานเป็นทีม

พัฒนา Website คนเดียวสบายกว่าทำงานเป็นทีมจริงหรือ?

Coding Beaver's photo
Coding Beaver
·Dec 21, 2021·

3 min read

Subscribe to my newsletter and never miss my upcoming articles

ผมมีอาชีพเป็น Software Developer (นักพัฒนาซอฟต์แวร์) แบบ เต็มเวลาในบริษัท Startup แห่งหนึ่งในประเทศไทยครับ

แต่ถึงว่าผมจะเรียกได้ว่าเป็นพนักงานประจำ แต่จริงๆแล้ว ผมไม่ชอบการทำงานในบริษัทสักเท่าไหร่เลยครับ...

ผมเป็นคนที่ชอบทำงานคนเดียวครับ

ซึ่งใครหลายๆคนก็คงชอบทำงานคนเดียวเหมือนกัน

ทำไมหน่ะหรอ?

  1. ผมไม่ชอบคุยสื่อสารกับคนบ่อยๆ: เวลาที่คุยกับคนแล้วรู้สึกว่าใช้พลังงานเยอะ มีความเครียดในการวางตัว ยิ่งประชุมนานๆยิ่งแล้วใหญ่ รู้สึกว่าพอประชุมเสร็จก็หมดแรงทำงานแล้ว
  2. ผมชอบอิสรภาพ: ที่สามารถเลือกที่จะทำงานตอนไหนก็ได้ที่อยากทำ และพักผ่อนตอนไหนก็ได้ที่อยากพัก
  3. ผมไม่ชอบรับคำสั่งใคร: หลายๆคนน่าจะเป็นเหมือนกันนะครับ บางทีเราก็แค่อยากเป็นนายตัวเอง ไม่ชอบให้ใครมาสั่งให้ทำนู่นทำนี้

.

จากความคิดเหล่านี้ ทำให้หลายครั้งผมอยากที่จะลาออกจากงานประจำแล้วเป็นนายตัวเองจริงๆ แต่ที่ผมยังไม่ทำอย่างงั้น ก็มีเหตุผลอยู่ครับ

นั่นคือผมเป็นคนชอบลองก่อนที่จะตัดสินใจจริง เพราะกลัวการตัดสินใจที่รวดเร็วเกินไปจะนำไปสู่ผลลัพธ์หลายๆอย่างที่เราไม่อยากจะได้รับนั่นแหละ

🧐 ผมจึงทำเริ่มลองหาโปรเจค Web Development (พัฒนาเว็บไซต์) มาลองทำคนเดียวดู!

ซึ่งโปรเจคที่ผมได้ลองทำ ก็คือเว็บไซต์ Coding Beaver นี่แหละครับ

ซึ่งเว็บไซต์ที่ผมทำขึ้นมานี้ตั้งใจจะให้เป็นช่องทางสำหรับทุกๆคนที่สนใจอยากจะเรียนรู้เพื่อที่จะเป็น Developer มืออาชีพ โดยที่ไม่ต้องมีพื้นฐานการเขียนโปรแกรม หรือรู้เรื่องเว็บมาก่อนเลย

ถ้าใครอยากจะรู้รายละเอียดของการทำโปรเจคนี้มากขึ้น ในอนาคตผมจะมาเล่าให้ฟังเพิ่มนะครับ

.

ผมเริ่มต้นยังไง?

ผมเริ่มโดยการ "จัดเวลาว่าง" มาทำ

ใช้แล้วครับ ผมใช้คำว่า "จัดเวลาว่าง" เพราะว่าการรอให้มีเวลาว่างแล้วค่อยทำอะไรที่อยากทำมันไม่มีอยู่จริงครับ เพราะถ้าเอาแต่รอสุดท้ายก็ไม่ได้ทำอยู่ดี ไม่เชื่อคุณลองถามตัวเองดูก็ได้ว่าจริงมั้ย

ถ้าเราอยากทำอะไรที่เป็นชิ้นเป็นอันขึ้นมา เราต้อง จัดเวลา ให้กับสิ่งนั้น เพื่อที่ว่าเราจะได้ทำมันได้อย่างต่อเนื่อง ไม่ใช่ทำครั้งเดียวแล้วก็ล้มเลิกไป

.

ผมจัดเวลาให้กับการทำโปรเจคส่วนตัวนี้โดยให้เวลาตอนเช้าก่อนเริ่มงานประจำ และตอนเย็นถึงค่ำๆ หลังเลิกงานประจำ รวมถึงวันเสาร์ และอาทิตย์ด้วย (สำหรับวันเสาร์ และอาทิตย์ทำแค่เช้ากับเย็นนะครับ ตอนกลางวันก็พักผ่อนตามปกติ)

ถามว่าเหนื่อยมั้ยทำแบบนี้...

เหนื่อยสิครับ แต่ว่าไม่ได้เกินกำลังเกินไป และสิ่งที่ได้คือเราได้ลองทำสิ่งที่เราอยากทำจริงๆ ซึ่งสำหรับผมแล้ว ผมมองว่ามันคุ้มค่าครับ ดีกว่าปล่อยให้เวลาผ่านไปแล้วมานึกเสียใจทีหลังว่าทำไมเราถึงไม่ลงมือทำมันหล่ะ!

แต่ต้องระวังอย่าฝืนตัวเองด้วยครับ ถ้าใครอยากจะลองทำสิ่งที่ตัวเองอยากทำในขณะที่ยังทำงานประจำไปด้วย ผมแนะนำว่าทำเท่าที่ไหว เพราะยังไงเราก็เป็นนายตัวเอง เราสามารถเพิ่มความยืดหยุ่นให้กับชีวิตตัวเองได้ครับ

🤔 หลังจากทำไปซักระยะแล้วเป็นไง?

ในช่วงแรกๆ รู้สึกชอบมากๆเลยครับ หลงรักเลยก็ว่าได้

เพราะว่าเราได้ทำงานคนเดียวตามความปรารถนาที่มีมาตลอด และไม่ต้องเจอความยากลำบากในการคุยกับคนและการประชุม

อยากพักตอนไหนก็พัก และอยากทำตอนไหนก็ทำ

ผมรู้สึกตื่นต้นกับชีวิตขึ้นมาอีกครั้งหนึ่ง และพอทำไปได้ซักสัปดาห์นึง ก็ยิ่งเริ่มคิดว่าตัวเองมาถูกทาง และอยากที่จะลาออกจากงานประจำมาทำโปรเจคตัวเองอย่างเต็มเวลา เพราะความรู้สึกที่ได้มั่นช่างแตกต่างกันจริงๆ!

แต่... วันนึงผมก็ได้เรียนรู้ว่าการทำงานคนเดียวก็มี "ข้อเสีย" เช่นกัน

😩 ผมได้พบข้อเสียอะไรบ้างจากการทำงานคนเดียว?

หลังจากทำงานคนเดียวไปซักระยะนึงผมก็พบว่ามีปัญหาอย่างนึง ที่ถึงแม้ว่าทำงานคนเดียวก็ไม่ได้ช่วยแก้ให้ปัญหานี้หมดไปได้

ปัญหานั้นก็คือ Bug นั่นเอง!!!

สำหรับคนที่ไม่รู้ว่า Bug คืออะไร มันคือศัพท์ที่เราใช้เวลาที่โปรแกรม หรือสิ่งที่เราพัฒนาอยู่มีปัญหา ไม่ทำงานตามที่เราต้องการ หรือว่าทำให้ซอฟท์แวร์พังไปเลยก็นับเป็น Bug เหมือนกัน

ลองนึกภาพซอฟท์แวร์เหมือนจักรยานที่คุณขี่ก็ได้ครับ เมื่อคุณขึ้นขี่แล้วปั่นมันไป คุณคาดหวังว่ามันจะต้องปั่นไปข้างหน้าได้อย่างง่ายๆ แต่หาก วิศวกรที่เป็นคนสร้างจักรยาน ดันทำอะไรผิดพลาดบางอย่างกับการวางระบบโซ่ ล้อ และเพลาของจักรยาน ทำให้พอคุณขึ้นไปปั่นมันแล้วมันกลับถอยหลังซะนี่!

เช่นเดียวกัน นักพัฒนาซอฟท์แวร์ก็ต้องเจอกับปัญหาแบบนี้อยู่บ่อยๆเพราะเราก็เปรียบเสมือนวิศวกรที่สร้างซอฟท์แวร์นั่นเอง

.

ผมพบว่าพอทำงานคนเดียวแล้ว การแก้ปัญหาที่มาจากตัวเนื้องาน (ในกรณีของ นักพัฒนาซอฟท์แวร์ก็คือ Bug นั่นแหละ) แต่ไม่ได้มาจากการสื่อสารกับคนกลับยากยิ่งกว่าเดิมซะอีก

ซึ่งเป็นข้อเสียเปรียบของการทำงานคนเดียว ถ้าเทียบกับการทำงานเป็นทีม ที่หากเวลามี Bug ที่ไม่ได้แก้ง่ายๆเกิดขึ้น ทุกคนจะเข้ามาช่วยกันหาสาเหตุของปัญหา ใช้ความรู้และประสบการณ์ที่ตัวเองมี ช่วยกันแก้ไข และมักจะแก้ได้โดยใช้เวลาไม่นานนัก

.

นอกจากเรื่อง Bug แล้ว ผมยังพบว่า

การทำงานคนเดียวนั้น "ช้า" กว่าการทำงานเป็นทีมพอสมควร

หลายๆคนอาจจะคิดว่า ไม่จริงหรอกหน่า ทำงานคนเดียวต้องเร็วกว่าอยู่แล้วเพราะเราไม่ต้องถกเถียงกับคนนู้นคนนี้ กว่าจะประชุม และหาข้อสรุปแต่ละอย่างได้ใช้เวลาตั้งนาน

มันอาจจะจริงที่ เราลดเวลาการประชุมลงไปได้ แต่พอเริ่มลงมือพัฒนา (หรือที่เราชอบเรียกกันว่าเขียน Code นั่นแหละ) กลายเป็นว่าเวลาในการเขียน Code กลับเพิ่มขึ้นมาแทน

ผมจะลองยกตัวอย่างให้เห็นภาพแบบง่ายๆ โดยการแบ่งขั้นตอนการทำงานพัฒนาซอฟท์แวร์เป็น 2 ขั้นตอนใหญ่ๆ

  1. ขั้นตอนการวางแผน และ ออกแบบ
  2. ขั้นตอนการลงมือทำ (เขียน Code นั่นเอง)

ความจริงแล้วขั้นตอนการทำงานอาจจะสามารถแบ่งย่อยออกได้มากกว่านี้ แต่ผมจะขอพูดถึงขั้นตอนแค่ 2 ขั้นตอนพอเพื่อให้เข้าใจง่าย

อย่างแรกที่ทุกคนต้องเข้าใจคือ การพัฒนาซอฟท์แวร์ต้องมีการวางแผน และออกแบบก่อน ถึงจะเริ่มลงมือทำจริงได้ เพราะไม่มีใครที่เขียน Code ได้โดยที่ไม่รู้เป้าหมายหรือสิ่งที่ซอฟท์แวร์จะต้องทำได้ (เหมือนจู่ๆผมจะบอกให้คุณขับรถไปส่ง โดยที่ไม่ได้บอกว่าให้ไปส่งที่ไหนนั่นแหละ)

หมายความว่าเราต้องวางแผน และออกแบบสิ่งที่จะทำให้เรียบร้อย ก่อนที่จะเริ่มลงมือทำ (ต้องทำขั้นตอนที่ 1 ให้เสร็จก่อน จึงจะเริ่มทำขั้นตอนที่ 2 ได้นั่นเอง)

ซึ่งถ้าให้วาดออกมาเป็นภาพ น่าจะได้ภาพแบบนี้

project-timeline.jpeg

มาพูดถึง "ขั้นตอนที่ 1 การวางแผน และออกแบบ" กันก่อน

จากประสบการณ์ของผมแล้ว การทำงานคนเดียว มักจะทำขั้นตอนนี้ได้เร็วกว่าการทำงานเป็นทีม เพราะเราไม่ต้องเสียเวลาถกเถียงว่ารูปแบบไหนดีกว่า หรือใช้เครื่องมือตัวไหนในการพัฒนาดี ซึ่งจะต้องผ่านการประชุมหนึ่งครั้งบ้าง สองครั้งบ้าง หรือมากกว่านั้น และการประชุมเนี่ยก็กินพลังงานกันไปพอสมควร

ต่อมาคือ "ขั้นตอนที่ 2 การเขียน Code"

สำหรับการเขียน Code ที่เป็นส่วนที่ผมชอบมากกว่าขั้นตอนที่ 1 เพราะไม่ต้องคุยกับคน แต่ผมกลับพบว่า "การทำงานเป็นทีม ทำให้เขียน Code ได้เร็วกว่าครับ"

เพราะอะไร?

เพราะว่าการเขียน Code นี้ สามารถแบ่งงานทำแบบคู่ขนาน (Parallel) กันได้ครับ พูดง่ายๆก็คือ แบ่งงานให้ นักพัฒนาหลายๆคน ทำไปพร้อมๆกันนั่นเอง

ยกตัวอย่างเช่น มีหน้าเว็บที่ต้องพัฒนาทั้งหมด 4 หน้า

ถ้า Developer คนเดียวใช้เวลา 2 ชั่วโมงในการพัฒนา 1 หน้า หมายความว่าถ้าต้องทำคนเดียวทั้งหมด 4 หน้า เราก็จะต้องใช้เวลา 2 + 2 + 2 + 2 เป็น 8 ชั่วโมงนั่นเอง

แต่ถ้าหากว่ามี Developer ทั้งหมด 4 คนหล่ะ?

ก็จะใช้เวลาทั้งหมดเพียง 2 ชั่วโมงเท่านั่นถูกมั้ยครับ เพราะว่าแต่ละคนเริ่มทำหน้าเว็บที่ตัวเองได้รับมอบหมายพร้อมๆกัน ใช้เวลาคนละ 2 ชั่วโมง งานทั้งหมดก็เสร็จเรียบร้อย! (อย่าลืมว่าต้องผ่านขั้นตอนที่ 1 นั่นคือวางแผนก่อนนะครับ)

ขอสรุปภาพเปรียบเทียบของการทำงานตามรูปด้านล่างนี้

working-time-comparison.jpeg

ซึ่งจะเห็นได้ว่าจำนวนคนที่เพิ่มขึ้นอาจทำให้งานบางอย่างเสร็จช้าลง (ในกรณีนี้คือขั้นตอนการวางแผนและออกแบบ เพราะว่าไม่สามารถแบ่งงานกันไปทำได้ แต่ต้องตกลงร่วมกัน)

และจำนวนคนที่เพิ่มขึ้นก็อาจทำให้งานบางอย่างเสร็จเร็วขึ้น (ในกรณีนี้ก็คืองานเขียน Code นั่นเองเพราะถ้าวางแผนร่วมกันเสร็จแล้ว ก็แยกย้ายกันไปทำได้)

.

และจากการลองทำโปรเจคด้วยตัวเองมานานหลายสัปดาห์ ผมก็ได้เรียนรู้แล้วว่า การทำงานพัฒนาซอฟท์แวร์คนเดียวมีข้อดีหลายอย่างจริงๆ แต่ในทางกลับกันก็มีข้อเสียด้วยซึ่งผมขอสรุปไว้ตามนี้

✅ ข้อดี

  1. ไม่ต้องคุยกับคนและไม่ต้องประชุม (สำหรับคนที่ชอบการประชุมอาจมองข้อนี้เป็นข้อเสียก็ได้นะ)
  2. มีอิสรภาพสูงมากๆ อยากจะทำงานตอนไหนก็ได้ และอยากจะพักตอนไหนก็ได้
  3. ไม่ต้องรับคำสั่งจากใคร
  4. ทำงานส่วนวางแผน และออกแบบ รวมถึงหาข้อสรุปต่างๆได้เร็ว (ไม่ต้องเถียงกับคนอื่นในที่ประชุม)

❌ ข้อเสีย

  1. แก้ปัญหาหรือ Bug ได้ช้ากว่า และไม่มีคนให้ขอความช่วยเหลือ
  2. ทำงานส่วนเขียน Code ได้ช้ากว่า ซึ่งถ้าเป็นโปรเจคที่ใหญ่ก็หมายความว่า งานทั้งงานทำได้ช้ากว่าแน่นอน

.

เป็นไงกันบ้างครับ อ่านกันมาถึงตรงนี้แล้วคุณคิดว่าตัวเองเหมาะกับการทำงานคนเดียว หรือการทำงานเป็นทีมมากกว่ากัน?

ผมคิดว่าทุกคนควรมีโอกาสได้ลองทำงานทั้ง 2 แบบดู ทั้งทำงานคนเดียว และทำเป็นทีม

เพราะอะไรหน่ะหรอ?

เพราะว่าคุณจะได้สัมผัสความรู้สึกด้วยตัวเอง ชั่งน้ำหนักดูถึงข้อแตกต่างของการทำงานทั้ง 2 แบบนั้น และหาคำตอบนั้นด้วยตัวคุณเองได้

💭 สำหรับตัวผม ผมมีความคิดเห็นอย่างนี้ครับ

ผมยังคงชอบการทำงานคนเดียวมากกว่าอยู่ดี ถึงแม้ว่าจะทำงานได้ช้าลงบ้างก็ตาม

แต่...

ผมเลือกที่จะยังทำงานประจำอยู่เหมือนเดิม และทำงานโปรเจคส่วนตัวเป็นงานเสริม เพราะมีเหตุผลอื่นนอกจากความชอบส่วนตัวที่ต้องนำมาพิจารณาด้วย

นั่นก็คือการทำงานเป็นทีมในบริษัท ผมยังคงได้เรียนรู้และพัฒนาจาก Developer คนอื่นๆอยู่เสมอจากการทำงานร่วมกัน ถึงแม้ว่าจะเหนื่อยบ้าง ไม่ชอบหลายๆอย่างบ้าง

นอกจากนั้นการทำงานในบริษัท โดยเฉพาะการเป็น Developer นั้น ทุกคนก็รู้ดีว่าให้ค่าตอบแทนที่ใช้ได้เลยทีเดียว แต่อย่าเข้าใจผิดว่าผมเป็นคนหน้าเงินนะครับ แต่เราทุกๆคนก็ต้องมองถึงอนาคตของชีวิตกันทั้งนั้น

และสำหรับช่วงเวลาของชีวิตที่ผมยังมีแรง มีกำลัง ผมอยากจะใช้ช่วงเวลานี้ในการเรียนรู้ รวมถึงสั่งสมความมั่งคั่งไว้เพื่อไม่ให้ต้องลำบากตัวเอง ครอบครัว และคนรอบข้างในอนาคตด้วย

.

แต่ก็ไม่แน่นะครับในอนาคต ผมอาจจะเปลี่ยนความคิด และเลิกทำงานประจำจริงๆก็ได้ เพราะไม่มีใครสามารถหยั่งรู้อนาคตได้ จริงมั้ยครับ

☝🏼 คำแนะนำสำหรับมือใหม่ที่อยาก เริ่มต้นอาชีพนักพัฒนาซอฟท์แวร์ (Software Developer)

ส่วนนี้ผมอยากจะพูดโดยตรงกับมือใหม่ทุกคน ที่หลายอาจจะแค่สนใจ หลายคนเพิ่งเริ่มต้นศึกษา หรือหลายคนเริ่มเรียนรู้มาได้ไม่นาน

ผมอยากจะบอกว่าการที่คุณอ่านบทความนี้มาถึงตรงนี้ คุณกำลังมาถูกทางแล้วครับ

ผมเชื่อว่าการลองทำอะไรบางอย่าง เราควรจะลองทำให้นานพอ เพื่อที่เราจะได้บอกได้จริงๆว่า เราชอบมันหรือไม่

วันนี้คุณอาจจะยังแค่เริ่มต้น แต่ก้าวเล็กๆทุกๆก้าว จะรวมกันแล้วเกิดเป็นความสำเร็จที่ยิ่งใหญ่ได้ ผมเชื่ออย่างนั้น

ผมอยากจะบอกให้ทุกคนพยายามเรียนรู้ต่อไป ศึกษาต่อไป ค่อยๆพัฒนาตัวเองให้เก่งขึ้นทุกๆวัน วันละนิดวันละหน่อย

เริ่มต้นวันนี้ เพื่อซักวันหนึ่งเมื่อคุณมองย้อนกลับมา คุณจะไม่เสียใจเลย... ผมเชื่ออย่างนั้นจริงๆครับ

Coding Beaver ขอเป็นกำลังใจให้ครับ

.

ขอพระเจ้าอวยพรทุกคนครับ

📖 เรียนรู้เพิ่มเติม

 
Share this