ก็แค่ใช้ Java ไปเถอะ
(teamten.com)- ภาษาที่ฉันชอบที่สุดคือ Python แต่ถึงอย่างนั้นฉันก็ใช้ Java กับทุกอย่าง แม้แต่สคริปต์ง่าย ๆ
- ประสบการณ์บางอย่าง:
- ในบริษัทที่ใช้ Java เป็นหลัก เคยเขียน test scenario ด้วย JavaScript แต่ตาม stack trace ได้ยาก และต้องเสียแรงเขียน bridge code ระหว่าง Java กับ JavaScript โดยใช่เหตุ
- เราเคยเก็บล็อกในรูปแบบ JSON แล้วมีเพื่อนร่วมทีมคนหนึ่งสร้างโปรแกรมชื่อ
logcatสำหรับจัดการล็อกเหล่านี้ ฉันพอใจกับโปรแกรมนั้นดี แต่หลังจากนั้นพอทำโปรแกรมคล้ายกันด้วย Java กลับได้ประสิทธิภาพดีขึ้นมากกว่า 10 เท่า - ด้วยประสบการณ์และแหล่งข้อมูลเกี่ยวกับ Java ที่มีอยู่มากมาย การสร้างเว็บเซอร์วิสด้วย Java จึงเร็วกว่า Python พูดให้เคร่งครัดกว่านั้น นี่คือข้อดีของการใช้ภาษาเดียวกัน
- ประเด็นถกเถียงที่ร้อนแรงที่สุดเกี่ยวกับ Java คือความ verbose (เขียนยืดยาว) แต่นี่ไม่ใช่ข้อเสียเลย ลองดูโค้ดสองชุดด้านล่าง
// java
Map<String,User> userIdMap = new HashMap<String,User>();
// python
userIdMap = {}
- แต่ในความเป็นจริง โค้ด Python มักจะถูกเขียนออกมาแบบนี้มากกว่า (ไม่อย่างนั้นคงดูแลรักษายากมาก)
# Map from user ID to User object.
userIdMap = {}
- กล่าวคือ การใช้ภาษาที่เป็น dynamic type ก็เหมือนการยอมสละ productivity หลังจากผ่านไป 14 วัน เพื่อแลกกับการทำของเจ๋ง ๆ ให้เสร็จใน 30 นาที
- Stack Overflow ใช้ ASP.NET และในปี 2010 ก็รองรับ 60,000,000 page views ได้ด้วยเซิร์ฟเวอร์เพียง 5 เครื่อง
- ลองดูตัวอย่างของ unit test การเขียนและดูแลรักษา unit test กินเวลาไม่น้อย โดยเฉพาะกรณียกเว้นที่ตรวจสอบได้ง่ายด้วย type นั้น มักจับได้ไม่ดีนักด้วย unit test ในภาษา dynamic type (เช่น parser)
- (ถ้าจะเพิ่มอีกเหตุผลหนึ่งว่าทำไมไม่ใช้ Python) quick hack ที่ทำแบบเฉพาะหน้ามักจะค่อย ๆ ใหญ่ขึ้นจนกลายเป็นเครื่องมือสำคัญมาก แต่ก็ไม่มีเวลามานั่งเขียนใหม่ สุดท้ายเลยต้องทรมานกับทั้ง performance และการดูแลรักษาทุกครั้งที่ใช้งาน
- สุดท้ายนี้ เหตุผลที่ชอบ Java มากกว่าภาษา static type อื่น ๆ
- C/C++ นำมาใช้กับงานของฉันได้ยาก
- C# รองรับข้ามแพลตฟอร์มไม่ดีพอ
- Scala ซับซ้อนเกินไป
- ภาษาอื่นอย่าง D, Go ยังใหม่เกินไปสำหรับเอามาใช้กับงานของฉัน
- มีเหตุผลอยู่หลายข้อที่ผมนำบทความนี้มาแชร์ใน GeekNews:
- ผมเพิ่งเคยเห็นบทความแนว "ฉันชอบ Java มากจริง ๆ!" เลยรู้สึกแปลกใหม่ดี (ตอนเห็นแค่ชื่อเรื่องนึกว่าจะมีหักมุมเสียอีก...)
- ตรงที่ผู้เขียนมีชุดเครื่องมือของตัวเอง (ที่ทำด้วย Java) ก็น่าสนใจดี มันทำให้ผมนึกถึงภาพชายชราที่คุ้ย ๆ กระเป๋าแล้วหยิบอาวุธโบราณออกมา
- โดยส่วนตัวผมชอบทั้ง JavaScript และ Python มาก แต่พอมองเผิน ๆ ก็รู้สึกว่าภาษาเหล่านี้เองก็กำลังไปในทางของการ "นำ type เข้ามาไม่ทางใดก็ทางหนึ่ง" เหมือนกัน (TypeScript สำหรับ JavaScript,
typing/mypyสำหรับ Python) พอมาเห็นบทความนี้ก็ทำให้ผมคิดเหมือนกันว่า การที่ผมใช้ภาษา static type แบบที่ไม่บังคับ type เลยนั้น อาจใกล้เคียงกับความพึงพอใจส่วนตัวอยู่ไม่น้อย
- ผู้เขียนมีประสบการณ์ทั้งกับ Java และ Python จึงเปรียบเทียบสองภาษานี้โดยตรง แต่ ดูเหมือนไม่จำเป็นต้องจำกัดการคิดไว้แค่นั้นเสมอไป ในมุมที่กว้างขึ้น ทุกคนมีความเห็นอย่างไรเกี่ยวกับภาษา static type และ dynamic type?
PS. อย่าดูถูกภาษาใดภาษาหนึ่งแบบไร้สาระกันเลย :D
58 ความคิดเห็น
น่าจะเป็นประสบการณ์ที่เฉพาะตัวมาก แต่ผมคิดว่าปัญหาใหญ่ของ Java ไม่ใช่ตัวภาษาเท่าไรนัก แต่เป็น JVM มากกว่า
ผมเจอปัญหาที่มันจัดการหน่วยความจำได้ไม่ดีใน JVM หลายเวอร์ชันมาบ่อยเกินไปแล้ว
งั้นก็ไปสร้าง pandas กับ numpy มาใช้บน Java เองสิ คนที่พูดอะไรแบบนั้นไม่ควรอยู่ใกล้ตัวเลย
Java ก็ใช้กับเว็บแบ็กเอนด์ ส่วน Python ก็ใช้กับ AI ไง
ถ้าจะวัดกันเรื่องประสิทธิภาพก็ต้องใช้ Rust สิ ไม่ใช่เรื่องที่ทุกคนก็รู้กันอยู่แล้วเหรอ?
แต่ต่อไปสัดส่วนของ AI น่าจะสูงขึ้น ก็เลยคิดว่า
ถึงเวลาเลิกใช้ Java แล้วหรือเปล่า? บ้านเรามักมีแนวคิดว่า
ห้ามตามหลังคนอื่นนะ 555
ถ้า AI เป็นที่ต้องการมากขึ้น และงานอย่าง REST API ทั่วไปหรือ CRUD แบบเรียบง่ายถูกแทนที่จนไม่ต้องสร้างระบบแบบนั้นอีกต่อไป ก็อาจเลิกใช้ Java ได้เหมือนกัน
อีกทั้งในหลายกรณีโปรเจ็กต์ก็ไม่ได้ประกอบด้วยภาษาเดียว ดังนั้นผมคิดว่าคงจับคู่ภาษาเข้ากับวัตถุประสงค์ของโปรเจ็กต์แบบหนึ่งต่อหนึ่งไม่ได้ เพราะโดยทั่วไปมักใช้งาน Python เป็นอินเทอร์เฟซสำหรับเขียนโปรแกรม และใช้ native code ในส่วนที่ต้องการประสิทธิภาพสูง ถึงแม้บ้านเราอาจไม่ได้จัดโครงสร้างโปรเจ็กต์กันแบบนั้นบ่อยนักก็ตาม
บทนำค่อนข้างน่าเสียดายนิดหน่อยนะครับ ถ้าบอกวันที่ที่ต้นฉบับถูกเขียนไว้ก่อน คนที่อยู่ที่นี่สักครึ่งหนึ่งก็คงพอจะเข้าใจได้ในระดับหนึ่งว่า...
ผมเองก็เพิ่งสังเกตจากคอมเมนต์ของคนอื่นเหมือนกันครับ
แต่ตอนแรกผมเดาไปเองว่าเป็นบทความที่เขียนขึ้นเมื่อไม่นานนี้ และตอนอ่านก็ไม่ได้รู้สึกขัดอะไรเลย อย่างน้อยสำหรับผม มันก็ยังเป็นบทความที่โน้มน้าวใจได้อยู่ครับ
แยกจากประเด็นนั้น ต่อไปผมจะใส่ใจกับวันที่ให้มากขึ้นบ้างครับ 555
การถกเถียงกำลังดุเดือดขึ้น
หากมีข้อโต้แย้ง กรุณาเขียนเฉพาะเนื้อหานั้นเท่านั้น
คอมเมนต์ที่ขัดต่อหลักเกณฑ์การใช้งานเว็บไซต์ได้ถูกลบแล้ว
นอกจากนี้ โปรดทราบว่าเราได้ระงับบัญชีที่มีกิจกรรมซ้ำ ๆ ซึ่งไม่เป็นไปตามหลักเกณฑ์การใช้งานแล้ว
ขอความร่วมมือในการร่วมถกเถียงอย่างสร้างสรรค์
ผมเชื่อใน Google (v8) มากกว่า Oracle (JVM)
ตอนทำ Python แล้วมาเห็น Java ครั้งแรก รู้สึกว่ามันเยิ่นเย้อมากจริง ๆ แต่พอช่วงนี้เห็นโค้ดที่ต้องเขียนเพื่อเพิ่ม type hints แบบสมบูรณ์ให้ Python แล้ว ก็รู้สึกว่าไม่ได้ต่างขนาดนั้นเหมือนกัน 555 ข้อที่น่าเสียดายของ Java กลับน่าจะเป็น naming convention ที่พยายามตั้งชื่อเมธอดให้ยาวมาก ๆ มากกว่าครับ
1 มิถุนายน 2014
ผมเองก็ชอบภาษาแบบ static type เหมือนกัน
ภาษาแบบ dynamic type ก็มีส่วนที่ใช้งานสะดวกอยู่ แต่ในสภาพแวดล้อม production ก็มักมีหลายกรณีที่ทำให้การบำรุงรักษายากขึ้น
และภาษาแบบ dynamic type โดยทั่วไปมักมีปรัชญาการออกแบบที่มุ่งไปที่ "การเขียนโค้ดให้ง่าย" จึงมีหลายอย่างที่ภาษาเข้ามาจัดการให้อย่างเป็นนัย ๆ แต่เพราะแบบนี้ บ่อยครั้งก็เหลือพื้นที่ให้ปรับแต่งประสิทธิภาพได้น้อย
สุดท้ายแล้วคงต้องชั่งระหว่างความสะดวกในการพัฒนา กับการมีช่องให้ optimize ได้มาก แล้วเลือกให้เหมาะกับสภาพแวดล้อมการพัฒนาครับ
โพสต์เมื่อ 10 ปีก่อนเลยนะเนี่ย 555
ก็ใช่เลย 555
ก็แค่ใช้ Java
หลังจากเลิกใช้ Java ชีวิตของผมก็สงบขึ้น
มีเหตุผลรองรับอยู่แล้วที่อันดับความนิยมของ Java ในแบบสำรวจของ Stack Overflow ลดลงต่อเนื่อง ในเกาหลีโดยเฉพาะ มันยังพอใช้ตอนหางานได้ เพราะเฟรมเวิร์กภาครัฐนั่นดันล็อกให้ใช้ Spring ไปเสียแล้ว แต่ในโลกตะวันตก นอกจากงานเลกาซีแล้ว ดูเหมือนแทบจะไม่เหลือการเลือก Java ตอนเริ่มโปรเจกต์ใหม่กันแล้ว
ก็จริงที่มีเหตุผลในระดับนั้นอยู่ แต่ดูเหมือนคุณจะมองเหตุผลนั้นต่างออกไปนะครับ
แม้แต่ในเว็บไซต์ TIOBE เองก็ระบุว่าอันดับภาษาโปรแกรมควรใช้ดูเป็นข้อมูลอ้างอิงเท่านั้น และไม่ได้เกี่ยวข้องโดยตรงกับส่วนแบ่งตลาดหรือความนิยม
สรุปก็คือ Python อยู่อันดับ 1 แบบทิ้งห่างในด้านส่วนแบ่ง แล้วมีเครื่องมือที่ออกสู่ตลาดบ้างไหม?
สิ่งที่พบเจอกันบ่อยที่สุดคือ C/C++, .NET, Java (Kotlin) และ Swift
การที่มีคำถามและการค้นหาเยอะ ไม่ได้แปลว่าเป็นภาษาที่ถูกใช้งานมาก
Python เป็นภาษาที่ใครก็ใช้ได้แม้ไม่ได้เรียนสายนี้มาโดยตรง
จะปฏิเสธว่ามันได้รับความนิยมมากก็คงไม่ได้ แต่ในตลาดงานพัฒนาซอฟต์แวร์นั้นเป็นอีกเรื่องหนึ่ง
อินสตาแกรมใช้ Python สำหรับแบ็กเอนด์
ความหมายของคำว่า 'เครื่องมือที่ออกสู่ตลาด' อาจจะยังไม่ค่อยชัดเจนนัก แต่... แค่ Django, FastAPI, PyTorch, NumPy, Pandas และอื่น ๆ ก็มีเครื่องมือมากพออยู่แล้วไม่ใช่หรือ...?
เห็นชื่อเรื่องแล้วก็เข้ามาโดยคาดหวังคอมเมนต์ก่อนเลย 555 ช่วงนี้ขอบเขตที่ต้องพึ่งพาภาษาก็กว้างขึ้นแล้วเนอะ
ถ้าจำกัดอยู่แค่เรื่องต้นทุน Java มักมีค่าใช้จ่ายบนคลาวด์สูงเพราะการใช้หน่วยความจำครับ โปรแกรมที่เป็นภาษาแบบ static ซึ่งต้องใช้หน่วยความจำ 100MB, 200MB ถ้าเขียนด้วย Java ก็มักมีหลายกรณีที่ต้องใช้ 1G, 2G และ lightweight thread ก็มีหลายครั้งที่ใช้ไม่ได้เพราะปัญหาความเข้ากันได้ของไลบรารีครับ
ก็ใช้ Java ไปเลยครับ
Java ก็เป็นภาษาสแตติกเหมือนกันนะครับ... แต่ปัญหาเรื่องหน่วยความจำนั้นเป็นเรื่องของ garbage collector หรือ JVM มากกว่า และที่คุณพูดถึงว่า "โปรแกรมที่ต้องใช้หน่วยความจำ 100MB, 200MB ด้วยภาษาสแตติก" น่าจะหมายถึงภาษาเนทีฟอย่าง C, C++ มากกว่าครับ
ขออภัยสำหรับข้อมูลเพ้อครับ T_T
javaก็เป็นภาษาสแตติกเหมือนกัน เมื่อรวมค่าใช้จ่ายต่าง ๆ บนคลาวด์แล้ว ต้องคิดราว ๆ 30,000 วอนต่อหน่วยความจำ 1G เลย ทำให้บริการที่พัฒนาด้วย Java มีค่าใช้จ่ายสูงมากครับถ้ามีข้อยกเว้นอยู่ ก็เป็นภาษาแบบไดนามิกไทป์ แยกกันอีกประเด็นหนึ่งคือ ผมเห็นด้วยกับข้อโต้แย้งที่ว่าระบบชนิดข้อมูลกับการใช้หน่วยความจำเป็นคนละเรื่องกัน
ความหมายของข้อยกเว้นที่คุณกล่าวมาดูจะกว้างเกินไปสำหรับผมนิดหน่อย ช่วยอธิบายให้ละเอียดขึ้นอีกสักหน่อยได้ไหมครับ?
เท่าที่ผมเข้าใจ คำนิยามของภาษาที่มีระบบชนิดข้อมูลแบบสแตติก/ไดนามิกคือ ถ้าชนิดข้อมูลของตัวแปรถูกกำหนดตั้งแต่คอมไพล์ไทม์ และเวลาจะเปลี่ยนต้องทำอย่างชัดเจน แบบนั้นคือภาษาที่มีระบบชนิดข้อมูลแบบสแตติก ส่วนภาษาที่มีระบบชนิดข้อมูลแบบไดนามิกคือภาษาที่ในช่วงรันไทม์สามารถกำหนดชนิดข้อมูลของตัวแปรได้อย่างอิสระ และยังเปลี่ยนแบบโดยนัยได้ด้วยครับ
ถ้าต้องเจอสถานการณ์อย่างการทำ downcasting ตอนรันไทม์ Java ก็จำเป็นต้องตรวจสอบ type ตอนรันไทม์ ด้วยเหตุนี้ Java จึงเป็น dynamic type ในบริบทนั้น และสิ่งที่เกิดขึ้นก็คือ exception
โดยพื้นฐานแล้ว ถ้าไม่มีช่องว่างนี้ ก็ไม่จำเป็นต้องเรียก exception ว่าเป็น exception เลย
throwก็คงจะกลายเป็นเพียง syntactic sugar ของแพตเทิร์นที่เอาอ็อบเจ็กต์ที่จะ throw ไปเก็บไว้ในตัวแปร global แล้วgotoเช่นเดียวกับที่คุณกล่าวมา ภาษาโปรแกรมที่ตรวจสอบชนิดข้อมูลระหว่างรันไทม์เรียกว่า dynamic typing แต่สิ่งนี้พูดถึงค่าทั้งหมดที่ถูกจัดการในโปรแกรม หากยก Java ซึ่งเป็นหัวข้อของบทความนี้มาเป็นตัวอย่าง โค้ด Java จะถูกตรวจสอบชนิดข้อมูลในช่วงคอมไพล์ และนั่นยังแฝงนัยสำคัญไว้อีกอย่างคือ ค่าที่สอดคล้องกับตัวแปรนั้นต้องตรงกับชนิดของตัวแปร
การตรวจสอบชนิดข้อมูลเกิดขึ้นตอนรันไทม์แล้วถ้าเป็นชนิดข้อมูลแบบไดนามิก แบบนั้น C ก็ถือเป็นภาษาแบบไดนามิกด้วยหรือเปล่า? เท่าที่ทราบเหมือนจะมีแนวคิดเรื่อง
voidpointer อยู่ อยากทราบว่าความแตกต่างระหว่างสองอย่างนี้คืออะไรมี C คอมไพเลอร์ตัวไหนบ้างที่แทรกการตรวจสอบชนิดข้อมูลเข้าไปในโค้ด และทำให้เกิดข้อผิดพลาดอย่างชัดเจนเมื่อชนิดข้อมูลไม่ตรงกัน? ถ้ามี implementation แบบนั้น ช่วยยกตัวอย่างมาเพียงหนึ่งตัวอย่าง
C ไม่มีสิ่งที่เรียกว่าการตรวจสอบชนิดข้อมูลในกระบวนการนั้นเลย จะอ่านข้อมูล floating-point เป็นจำนวนเต็มก็ไม่มีปัญหาอะไรไม่ใช่เหรอ? มันไม่ใช่ว่าเป็น dynamic typing แต่แค่เสี่ยงอันตรายเฉยๆ
ใช่ ถ้า C ตรวจสอบชนิดข้อมูลตอนรันไทม์ มันก็จะเป็นภาษา dynamic type
แต่เพราะมันไม่ได้เป็นแบบนั้น จึงเป็น static type
voidpointer ก็เป็นแค่ raw pointer ที่ไม่สามารถรู้ชนิดข้อมูลดั้งเดิมได้ เราไม่อาจรู้ได้ว่ามีข้อมูลชนิดใดอยู่ที่แอดเดรสที่ pointer นั้นชี้ไปความเห็นของผมคือ ภาษาเขียนโปรแกรมที่คุ้นเคยดีที่สุด
เห็นด้วยครับ ดูเหมือนว่าการจะออกนอกเหนือจากภาษาที่ทีมหรือองค์กรใช้อยู่ก็ไม่ใช่เรื่องง่ายเหมือนกัน
ในบรรดาหลายเหตุผลที่ทำให้เนื้องานหรือการจัดสรรงานถูกแยกออกจากกัน การเพิ่มภาษาเข้ามาเป็นอีกปัจจัยที่ทำให้เกิดภาระงานหนักกับคนบางคน และเมื่อมีการเปลี่ยนแปลงกำลังคน งานก็เดินต่อไม่ได้
อีกทั้งยังเป็นปัจจัยที่ส่งผลต่อการจ้างงานด้วย เลยคิดว่าควรพิจารณาเลือก tech stack อย่างรอบคอบ
แต่ในทางกลับกัน ถ้ายึดติดกับภาษาเดิมเพียงเพราะคุ้นเคย ทั้งที่มี talent pool สำหรับการจ้างงานน้อย หรือหลังรับเข้ามาแล้วต้องมีการเรียนรู้เพิ่มเติมเป็นพิเศษ แบบนั้นก็คงเป็นปัญหาเหมือนกัน
ทำไม C# ถึงยังขาดในแง่การเป็นข้ามแพลตฟอร์มล่ะ ทุกวันนี้แอปเซิร์ฟเวอร์ .NET ส่วนใหญ่ก็ deploy บนเซิร์ฟเวอร์ Linux กันอยู่แล้ว
แต่แรกแล้ว Python ก็ไม่ใช่คู่เทียบกันอยู่แล้ว และเมื่อเทียบกับ Kotlin กับ C# ก็ดูจะยืดยาวกว่าและขาดฟีเจอร์ที่จำเป็นไปหลายอย่างจริง ๆ
อ๋อ นี่เป็นบทความเมื่อ 10 ปีก่อนสินะ ตอนนี้สถานการณ์เปลี่ยนไปมากแล้ว
C# ก็เป็นภาษาที่ใช้ virtual machine ดังนั้นจริง ๆ แล้วการรองรับข้ามแพลตฟอร์มน่าจะออกมาตั้งนานแล้ว แต่เท่าที่ผมรู้ เหมือนเพิ่งมีออกมาได้ไม่นานมาก เพราะงั้นภาพจำว่ามันพอจะรันบน OS อื่นที่ไม่ใช่ Windows ได้ ก็คงยังคงอยู่ไปอีกสักพัก
ยิ่งไปกว่านั้น ถ้าเป็นสภาพแวดล้อม Linux ที่เน้นเซิร์ฟเวอร์ซึ่งทำงานตลอด 365 วันต่อปี ก็เป็นความจริงเหมือนกันว่าคนจะลังเลกับ .NET ที่ยังไม่ได้ผ่านการพิสูจน์อย่างเพียงพอ เมื่อเทียบกับภาษาอื่นที่มีการพิสูจน์เสถียรภาพบนระบบนั้นมานานกว่า 10 ปี
ในความหมายนั้น เขาถึงพูดกันว่า cross-platform ยังไม่ดีพอหรือเปล่า
แล้วเกณฑ์ที่ใช้ตรวจสอบว่าเสถียรจริง ๆ คืออะไรกันแน่ครับ? หมายถึงแค่ระยะเวลาที่ใช้งานหรือเปล่า ผมไม่ค่อยเข้าใจครับ
เป็นบทความเมื่อ 10 ปีก่อน จึงเขียนออกมาแบบนั้นเพราะตอนนั้น .NET Core เพิ่งถือกำเนิดได้ไม่นาน
ตอนนี้แอปพลิเคชัน .NET ทำงานบน Linux และ macOS ได้อย่างเสถียรดีอยู่แล้ว
ฉันเคยตามหาภาษาที่มีไวยากรณ์กระชับแบบ Python แต่มี static typing ติดมาด้วย แล้วก็บังเอิญไปเจอ GDScript เข้า แต่ข้อเสียใหญ่มากคือมันยากที่จะนำไปใช้งานอย่างแพร่หลายโดยทั่วไป
ถ้ามีโอกาส ผม/ฉันแนะนำให้ลองทำโปรเจกต์เล็ก ๆ ผ่าน Godot แล้วลองสัมผัส GDScript ดูครับ/ค่ะ
ใช้ Java ไปเถอะครับ
ผมพอได้ลอง Kotlin แล้วก็กลายเป็นคนเกลียด Java ไปเลย...
ผมรู้สึกว่าเวลา Java ต้องการฟีเจอร์อะไรสักอย่าง ก็มักจะมีคำตอบที่ผ่านการพิสูจน์แล้วอยู่เสมอ
ก็แค่ใช้ Java
ก็แค่ใช้ Kotlin.
ผมก็เคยส่งอีเมลไปถามความเห็นเกี่ยวกับ Kotlin อยู่แล้วเหมือนกัน (ในฐานะที่ผมเองก็เป็นผู้ใช้ Kotlin) แต่ได้รับคำตอบกลับมาว่าไม่เคยลองใช้มาก่อน จึงตอบจากประสบการณ์ได้ยาก
ผมชอบภาษาแบบ static type ครับ เพราะมันช่วยลดความจำเป็นที่ต้องคอยคิดเรื่องพวกนั้น ทำให้เอาเวลาไปคิดอย่างอื่นได้
Java เป็นภาษาที่มีสถานะเฉพาะตัวมากจริง ๆ ถึงครั้งสุดท้ายที่ผมใช้ Java ในงานจะเป็นเมื่อราว 10 กว่าปีก่อน แต่ถ้าตอนนี้ต้องพัฒนาโปรแกรมอะไรสักอย่างเพื่อการทำงาน ไม่ใช่งานอดิเรก มันก็ยังอยู่ในรายชื่อภาษาที่ผมจะพิจารณาเป็นอันดับต้น ๆ
ตอนนี้ภาษาหลักที่ใช้ในงานคือ Ada กับ C แต่เครื่องมือที่ใช้ส่วนตัวหรือใช้กันในทีมส่วนใหญ่จะเขียนด้วย PowerShell แต่พอเขียนไปแล้วปล่อยเวลาให้ผ่านไปนิดเดียว (แค่ 5 นาที...) ก็จะเริ่มคิดว่า "ตัวแปรนี้เป็น type อะไรนะ?" ช่วงนี้เลยพยายามระบุ type ให้ชัดเจนเสมอ (PowerShell สามารถกำหนด type ให้ตัวแปรตอนประกาศได้ หรือจะละไว้แล้วใช้งานแบบ dynamic ก็ได้)
ผมเองก็ไม่ค่อยชอบ C เท่าไร เพราะข้อผิดพลาดเรื่อง type ที่ถ้าเป็น Ada คอมไพเลอร์จะช่วยกรองออกให้ แต่ C กลับจับไม่ได้เลย ผมเลยมักจะคิดอยู่บ่อย ๆ ว่าถ้ามีภาษาที่ไวยากรณ์คล้าย C แต่รองรับระบบ type แบบ Ada ก็คงดี
ส่วน Javascript กับ Python ก็ยังไม่ค่อยถูกจริตเท่าไร สำหรับ Perl หรือ Shell Script... ไม่อยากคิดถึงเลยครับ.
คงช่วยไม่ได้เพราะปรัชญาพื้นฐานของภาษา C คือ "จงเชื่อใจโปรแกรมเมอร์"..
อ้อ แล้วผมชอบ Java นะ แต่เกลียด Maven
ในยุคทองเมื่อก่อนน่ะ Ant ทำได้ทุกอย่างเลย!
อย่างน้อยก็ยังนับว่าโชคดีที่ Java กำลังค่อย ๆ ไล่ตามภาษาสมัยใหม่อยู่ เช่น มีการเพิ่ม record และ pattern matching เข้ามา
Java มีข้อมูลอ้างอิงเยอะก็ดีอยู่หรอก แต่ถ้ามีแค่นั้นอย่างเดียวก็อดสงสัยไม่ได้ว่าทำไมถึงไม่ใช้ C++ แทน
น่าจะดีถ้ามีการพูดถึงข้อดีของ Java มากกว่านี้อีกหน่อย
ผมยกตัวอย่าง c++ ก็เพียงเพราะปกติผมใช้ c++ เป็นหลักเท่านั้นเองครับ ส่วนตัวผมก็คิดว่า java เป็นภาษาที่ดีเหมือนกัน แต่สิ่งที่ผมอยากชี้คือ โพสต์ต้นฉบับนั้นพูดถึงข้อดีของ java ไม่มากพอ
ถ้าเขียนว่า ชอบ java มาก เนื้อหาหลักก็ควรเป็นเรื่องข้อดีของ java แต่ผมรู้สึกว่าเนื้อหาหลักกลับเหมือนเป็นการวิจารณ์ภาษาอื่นมากกว่า
และอย่างที่คุณแสดงความเห็นไว้ ผมก็คิดว่า JVM ของ java นั้นยอดเยี่ยมมากครับ
เห็นด้วยอย่างยิ่งครับ คำชี้แจงที่บอกว่าไม่จำเป็นต้องจำกัดการพูดไว้แค่ Java ก็มีเจตนาแบบนั้นแหละครับ แต่ดูเหมือนจะสื่อสารออกไปได้ไม่ค่อยชัดนัก..
พอเทียบกับ Java และ C++ ความน่าเชื่อถือก็ลดฮวบไปหน่อยเลยนะ 555
ก็แค่ใช้ Java เถอะ
Java รันอยู่บน JVM จึงสามารถตั้งค่าสภาพแวดล้อมให้เหมือนกันได้ทั้งบนเครื่องโลคัลและเครื่องปลายทาง แต่ถ้าจะทำให้สภาพแวดล้อมของนักพัฒนาทุกคนและทุกเครื่องเหมือนกันทั้งหมดด้วย C++ คงต้องใช้เวลามากพอสมควร แถมยังดูแลรักษายากอีก...
ดูเหมือนว่าผู้เขียนต้นฉบับจะใช้ Java ก็เพียงเพราะเป็นงานที่นำ C++ มาใช้ได้ยาก ถ้าต้องเลือกสักอย่างระหว่าง Python กับ C++ ก็น่าจะเลือก C++ ไม่ใช่หรือ?
แก้ไข: "สุดท้าย เหตุผลที่ไม่ใช่ภาษา static type อื่น ๆ" -> "สุดท้าย เหตุผลที่ชอบ Java มากกว่าภาษา static type อื่น ๆ"
ฟืนติดไฟดีจริง.. แนะนำอย่างแรง
นี่ไม่ใช่ไฟที่ฉันต้องการเลย ฮือ
อุ่น..นะ..