ComBioLaw.De

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

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

ผมจึงรู้สึกว่า น่าจะเขียนบล็อกขึ้นมาหนึ่งบล็อก เพื่อเปรียบเทียบคุณสมบัติต่าง ๆ ของภาษาเขียนโปรแกรมขึ้นมาหนึ่งบล็อก เพื่อเปรียบเทียบให้เห็นกันจะ ๆ และพยายามเป็นกลางให้มากที่สุด (อันนี้แหละยาก) เผื่อว่าใครจะเอาข้อมูลไปใช้ประกอบการตัดสินใจ โดยภาษาที่ผมจะนำมาเปรียบมวยมีด้วยกัน 3 ภาษา คือ Java, Python และ Ruby เพราะเป็นภาษาที่ได้รับความนิยมในขณะนี้ และดูที่อนาคตจะไปได้สวย (จริง ๆ อยากเขียน C# เหมือนกัน แต่ดูเหมือน C# จะแผ่วไปเยอะในช่วงหลัง)

อันที่จริง ...

เขียนโปรแกรม

bow_der_kleine

มีคนเปรียบมวย Python กับ Java ไว้แล้วเยอะเหมือนกัน ไม่ว่าจะเป็น Python & Java: Side by Side Comparison

(รู้สึกหน้านี้จะเสีย ลองไปอ่านที่ Google-Cache ดูครับ), C++ vs Java vs Python vs Ruby : a first impression และ Python vs. Perl vs. Java vs. C++ Runtimes แต่ส่วนมากมักเป็นข้อมูลเก่า (ยกเว้น C++ vs Java vs Python vs Ruby : a first impression ข้อมูลค่อนข้างใหม่) ผมจึงอยากอัพเดดข้อมูลบางอย่างเพิ่มเติมลงไป และทดสอบโดยใช้โปรแกรมที่ใกล้เคียงกับการใช้งานจริงมากที่สุด

About me

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

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

ผมไม่เคยศึกษา Ruby อย่างเป็นเรื่องเป็นราว แต่ก็ผ่าน ๆ ตามาบ้าง โดยการใช้งาน Ruby on Rails ความรู้ Ruby ผมจึงเป็นแบบ งูงู ปลาปลา อย่าถือสากันนะครับ :D

About this fight

ส่วนการทดสอบความเร็วนั้น ผมได้อ้างอิงตาม Python vs. Perl vs. Java vs. C++ Runtimes โดยมาปรับปรุงสำหรับ Ruby และเพิ่มการทดสอบในกรณีอื่น ๆ เข้าไปอีกเล็กน้อย

ในแต่ละยกผมจะให้คะแนน แต่ละภาษาโดยให้เป็น ยิ่งมากยิ่งดี โดยมีคะแนนเต็ม (คิดถึงตอนเรียนอนุบาลเลย)

Round 1 : The first impression

• Java : : เป็นภาษาที่เหมาะกับวิศวกรซอพท์แวร์ แต่ไม่ค่อยถูกโฉลกกับคนวงการอื่น ๆ ในครั้งแรกที่เริ่มเขียน Java อะไร ๆ ก็ดูยากไปหมด ผมและเพื่อนทุกคนเห็นพ้องต้องกันตอนเรียน Java ว่า Java ยากกว่า C อีก อีกทั้งตัวภาษาไม่เอื้อต่องานประเภท Quick and Dirty คือลองเขียนเล่น ๆ สั้น ๆ คนที่จะเขียนโปรแกรม Java โปรแกรมแรกได้นั้น ต้องรู้จัก JRE, JDK, class, object, public, static, void, main ก่อนถึงจะเขียนได้ อีกทั้งยังเจอ Concept แปลก ๆ ที่คนที่ไม่เคยเขียน Java มาก่อน ก็ต้องงงไปตาม ๆ กัน เช่น Interface, Abstact Class, Iteration, Type Cast เป็นต้น สรุปคือ กว่าจะเขียน Java เป็นต้องใช้เวลาค่อนข้างนาน
• Python : : คงเหมือนกับภาษา Script ภาษาอื่น ๆ ที่ไม่ต้องรู้อะไรมากก็ลงมือเขียนได้เลย มี Interactive-Console ให้ใช้งาน ลองเล่นไปตามเรื่องตามราว แต่สิ่งที่กวนประสาทมาก ๆ คือ Indent เป็นเรื่องที่ต้องใช้เวลาในการปรับตัวกันนานพอสมควร
• Ruby : : ครั้งแรกที่ลองใช้งาน อะไร ๆ ก็ดูง่ายไปหมด หากรู้จักภาษา Script อื่น ๆ มาก่อน Ruby แล้ว การเรียนรู้ Ruby ก็จะใช้เวลาน้อยมาก

Round 2 : Community

• Java : : เนื่องจาก Java เป็นภาษาที่ได้รับความนิยมสูงสุด มีบริษัทยักษ์ใหญ่จำนวนมากให้การสนับสนุน Java และเลือก Java เป็นภาษาหลักในพัฒนาซอพท์แวร์ของตัวเอง อีกทั้งในขณะนี้ Java กลายเป็น OpenSource เป็นที่เรียบร้อยแล้ว ดังนั้น Community ของ Java จึงแข็งแกร่งไร้เทียมทาน
• Python : : Python เป็น OpenSource โดยกำเนิด และเป็นภาษาที่ได้รับความนิยมมากขึ้นเรื่อย ๆ มีองค์กรณ์สนับสนุนอย่างเป็นทางการมากมาย (PSF, Google, Zope) แม้ความนิยมในตัว Python ยังไม่เทียบเท่า Java แต่ความแข็งแกร่งของ Community ก็ไม่ได้เป็นรอง Java แม้แต่น้อย
• Ruby :: แม้ว่า Ruby จะเป็นภาษาที่ค่อนข้องใหม่ แต่ในระยะเวลาสองปีที่ผ่านมา Ruby ได้รับความนิยมเพิ่มขึ้นอย่างรวดเร็ว สาเหตุก็เนื่องมาจาก Ruby on Rails ความแข็งแกร่งของ Community ของ Ruby จึงเพิ่มขึ้นอย่างน่าจับตามอง แม้กระนั้นก็ตาม Community ของ Ruby ยังอยู่ในภาวะสร้างตัว จึงยังไม่แข็งกร่งเท่าภาษาเขียนโปรแกรมรุ่นพี่อย่าง Java และ Python แต่คาดว่าอีกปีหรือสองปี Ruby อาจเทียบชั้นมาตีเสมอได้ไม่ยาก

Round 3 : Library

• Java : : เนื่องจาก Java เป็นภาษาที่ได้รับความนิยมอย่างสูง จึงไม่ใช่เรื่องแปลกที่ Java จะมี Library ให้เลือกใช้มากมาย โดยเฉพาะอย่างยิ่งการเขียนโปรแกรมเชิงธุรกิจ แต่ Library ส่วนใหญ่ของ Java ได้รับการออกแบบมาซับซ้อนเกินไป ทำให้ใช้ยาก อีกทั้งยังขาด Library สำหรับโปรแกรมทางวิทยาศาสตร์อีกจำนวนมาก
• Python : : แม้ว่า Library ของ Python คลอบคลุมการใช้งานมากกว่า Java (ทางวิทยาศาสตร์, Image Processing, Latex, 3D-Rendering, etc.) แต่ Library ส่วนใหญ่ยังมีมาตรฐานไม่เทียบเท่าของ Java ส่วนหนึ่งเนื่องมาจากเป็นโครงการ OpenSource ขนาดเล็ก
• Ruby : : ความเป็นภาษาใหม่ของ Ruby ทำให้ Ruby มี Library ให้เลือกใช้ยังไม่มากนัก แต่ Library ของ Ruby ก็น่าจับตามอง เนื่องเพราะเป็น Library ที่ใช้งานง่าย และมีมาตรฐาน เมื่อเปรียบเทียบกับ Java และ Python

Round 4 : Time to code

• Java : : ใครบอกว่า Java เขียนง่ายผมคนหนึ่งล่ะที่ไม่เชื่อ คนส่วนใหญ่บอกว่า Java เขียนง่ายกว่า C++ ผมเห็นด้วยเพียงครึ่งเดียว Concept ของ Java แม้จะทำให้เขียนโปรแกรมง่ายกว่า C++ ก็จริง แต่ก็เข้าใจยากกว่าเหมือนกัน (แค่ Itration อ. ที่สอนต้องใช้เวลาอธิบายอยู่หลายอาทิตย์ กว่าพวกผมจะเข้าใจ) และเนื่องจาก Java ยังเป็น Compiled Language อยู่ การลองโน่นลองนี่จึงไม่ใช่เรื่องง่าย เพราะต้องเสียเวลาในการ Compile อีกทั้งความพยายามออกแบบ Java ให้ Common มากที่สุด ก็ทำให้ Java ซับซ้อนเกินกว่าเหตุ
• Python : : ความเป็น Script ของ Python ทำให้การเขียนโค้ดด้วย Python รวดเร็วทันใจอยู่แล้ว บวกกับคอนเซพท์ที่เข้าใจง่ายของ Python ยิ่งทำการเขียนโค้ดของ Python เร็วขึ้นไปอีก เครื่องมือในการหาข้อผิดพลาดที่พร้อม คุณภาพโค้ดที่ได้ก็สูง เพราะโดนบังคับโดยตัวภาษา โครงสร้างของภาษาที่รองรับโครงการขนาดใหญ่ โดยส่วนตัวผมเห็นว่า Python น่าจะเป็นภาษาที่เขียนโค้ดได้เร็วที่สุดในขณะนี้
• Ruby : : คุณสมบัติดี ๆ หลายอย่างของ Perl และ Python ถูกสอดแทรกลงใน Ruby ได้อย่างลงตัว แม้ว่า Ruby จะเป็นภาษาที่ใช้เครื่องหมายมากเกินไป (ออกแนว Perl) ทำให้โค้ดที่ได้อ่านยากไปบ้าง แต่ก็ถูกทดแทนด้วยคอนเซพท์หลายอย่างที่ไม่เหมือนใคร (symbol, attr_reader) ในขั้นต้นการเขียนโค้ดด้วย Ruby อาจเร็วกว่า Python แต่ในระยะยาว Ruby อาจประสบปัญหาเดียวกับ Perl คือ Write only coding

Round 5 : How does the language do ?

• Java : : สำหรับผมแล้วการแบ่งบล็อกด้วยวงเล็บปีกกา {} เป็นการแบ่งบล็อกที่ผมชอบมากที่สุด เพราะสามารถทำได้ง่าย รวดเร็ว และชัดเจน แม้ว่าจะมีปัญหาเกิดขึ้นบ้าง เวลาที่มีบล็อกซ้อนบล็อกมากเกินไป แต่ปัญหานี้ไม่ว่าจะใช้วิธีการแบ่งบล็อกแบบไหน ก็เกิดขึ้นได้ทั้งนั้น การเลี่ยงการเขียนบล็อกซ้อนบล็อกจึงน่าจะเป็นทางออกที่ดีกว่า
• Python : : แม้ว่าการแบ่งบล็อกด้วย indentation มีข้อดีหลายอย่าง ทั้งง่าย รวดเร็ว เป็นการบังคับให้คนเขียนโปรแกรมเขียนโค้ดที่อ่านง่าย แต่ก็มีอันตรายแอบแฝงหลายอย่าง เช่น การใช้ Tabalator ผสมกับการเว้นวรรค ขนาด indentation ที่ไม่เท่ากัน การเขียนโปรแกรมด้วย Python จึงต้องใช้ Editor ที่มีคุณภาพพอสมควร เพื่อป้องกันปัญหาดังกล่าว อีกทั้งต้องมีการตกลงกันระหว่าคนเขียนโปรแกรมว่าจะใช้ indentation แบบใด
• Ruby : : การแบ่งบล็อกด้วย begin และ end แม้ว่าจะทำให้อ่านง่ายขึ้น แต่ก็ง่ายกว่าการใช้วงเล็บปีกกาไม่มากนัก Ruby เองก็ไม่ใช่ภาษาที่อ่านง่ายอยู่แล้ว การใช้ begin และ end จึงไม่มีข้อได้เปรียบที่ชัดเจน นอกจากจะทำให้โค้ดยาวขึ้น

• Java : : การวนลูปของ Java เริ่มต้นเดิมทีได้นำวิธีการของ C มาใช้ จากนั้นก็เพิ่ม Iteration เข้ามา แม้ว่า Iteration จะได้เปรียบ for ธรรมดาอยู่หลายอย่าง แต่ก็ทำให้โค้ดที่ได้อ่านยาก ต้องเขียนโค้ดยาว งง ๆ คนส่วนมากจึงยังคงใช้ for ธรรมดามากกว่า Iteration ใน Java 5 จึงได้มี for-each เพิ่มเข้ามา แต่ก็ยัง for-each ที่ยัง งง ๆ อยู่ ถึงตอนนี้ผมยังคอมไพล์โปรแกรมที่มี for-each ไม่ผ่านเลยครับ
• Python : : คอนเซพท์ for-loop ของ Python ถือว่าเป็นคอนเซพท์ที่ดีมาก มีการนำ iteration มาใช้โดยที่คนเขียนไม่ต้องทำความเข้าใจเรื่อง iteration แต่อย่างใด for-each เป็นการวนลูปที่เร็วที่สุดใน Python (เร็วกว่า while) มีฟังก์ชั่น zip() ให้ใช้ ทำให้สามารถใช้ for-each กับข้อมูลสองชุดที่มีขนาดเท่ากันพร้อมกันได้
• Ruby : : คอนเซพท์วนลูปของ Ruby คล้ายคลึงกับของ Python มาก ข้อเสียเดียวที่ผมมองเห็นในการวนลูปของ Ruby คือ incosistence Ruby มีการวนลูปหลายรูปแบบเกินไป ทำให้เกิดความสับสนในการใช้งานในบางครั้ง

• Java : : ตอนผมเรียน Java อ.ที่สอนท่านชอบบอกว่า Collection-Classes ของ Java มันเจ๋งอย่างไรบ้าง หากเปรียบมวยกับ Array ของ C++ มันก็เจ๋งกว่าจริง ๆ นั่นแหละ แต่มันซับซ้อนมาก ๆ มากเกินไป การทำความเข้าใจ Collection-Classes ของ Java ให้แตกฉาน เป็นศาสตร์ และศิลป์ในตัว ต้องใช้เวลานาน มีจำนวน Classes ให้เลือกใช้มากเกินไป ทั้งที่แต่ละ Class ก็ไม่ต่างกันมาก การนำข้อมูลดิบใส่ลงไปใน Container ก็ไม่ใช่เรื่องง่าย ๆ (ดูตัวออย่างโปรแกรม)
• Python : : ใน Python มี Container เพียงสามแบบ คือ [List], {Dictionary} และ (Tuple) สามารถนำไปใช้งานง่าย คลอบคลุมทุกการใช้งาน เจ๋งไหม
• Ruby : : คอยเซพท์ Container ของ Ruby เหมือนของ Python ทุกอย่าง แต่ไม่มี Tuple ให้ใช้

Round 6 : OOP

• Java : : Java เป็นภาษาเขียนโปรแกรมที่นำทฤษฎี OOP มาใช้งานได้เต็มรูปแบบ และสมบูรณ์ที่สุด มีเพียง C# เท่านั้น ที่สามารถเทียบชั้นกับ Java ได้ในเรื่องนี้ แต่คำถามคือ เรามีความจำเป็นเพียงใด ในการใช้ OOP เต็มรูปแบบ
• Python : : แม้ว่า Python จะรองรับการเขียนโปรแกรมแบบ OOP แต่ผมก็มองว่าเป็น OOP แบบขำ ๆ มีคอนเซพท์ OOP หลายอย่างที่ขาดใน Python (public, private, protected, interface, abstact calss, etc.) อีกทั้งทุกอย่างใน Python ไม่จำเป็ต้องเป็น Object สำหรับคนที่เรียน วิชา Software Engineering หรือ Software Architect มา อาจเริ่มต้นกับ Python ไปไม่ถูกเหมือนกัน แต่สิ่งเหล่านี้ถูกทดแทนได้โดย Meta- , Functional-Programming และ Dynamic Typing
• Ruby : : Ruby อาจไม่รองรับ OOP เท่า Java แต่ดีกว่า Python และทำหน้าที่ OOP ได้อย่างไม่ขาดตกบกพร่อง OOP ในส่วนที่ขาดไปของ Ruby สามารถทดแทนได้ด้วย Dynamic Typing

Round 7 : Web-Development

• Java : : แม้ว่า Java จะสร้างชื่อเสียงของตัวเองด้วยการใช้งานบนอินเตอร์เนต แต่ Framework เกี่ยวกับ Web-Development ของ Java ก็ไม่เคยประสบความสำเร็จอย่างจริงจัง Applet โดนโลกลืมอย่างน่าสงสาร Servlet และ JSP ก็โดน PHP กินส่วนแบ่ง ทิ้งห่างอย่างไม่เห็นฝุ่น เพราะมันดันใช้ยาก และตะกละตะกลาม แม้ว่าจะมี Web-Framework ใหม่ ๆ ออกมาให้ใช้งานมากมาย แต่ก็กินส่วนแบ่งกันเอง และไม่มีนวัตกรรมใหม่ ๆ ที่น่าสนใจ
• Python : : Plone ถือเป็น Killer Application ของ Python และเป็นเครื่องยืนยันได้ถึงคุณภาพด้านนี้ของ Python ได้อย่างดี อีกทั้ง Google และ YouTube ต่างก็หันมาใช้ Python อย่างออกหน้าออกตา สำหรับ Framework ก็มีทั้ง Zope , Django และ Turbo-Gear ให้เลือกใช้ แต่ปัญหามันอยู่ตรงนี้แหละครับ มันมีให้เลือกใช้เยอะเกินไปจน inconsistence
• Ruby : : บอกได้คำเดียวครับว่า Rails มันสุดยอด

Round 8 : GUI

• Java : : เป็นจุดอ่อนของที่ติดตัว Java มานานนับปี AWT , SWT และ Swing ต่างก็มีจุดอ่อนจุดแข็งของตัวเอง แต่เมื่อเปรียบเทียบทั้งสามกับ GUI ภาษาอื่น บอกได้เลยครับว่ามันห่วย สาเหตุก็เนื่องมาจาก Java มันเป็น Manage Code จึงไม่สามารถดึงพลังของ CPU มาใช้สำหรับ GUI ได้เท่า Native Code
• Python : : Python เป็นภาษาเขียนโปรแกรมที่มี GUI ให้เลือกใช้มากที่สุดภาษาหนึ่ง ไม่ว่าจะเป็น Tk, Qt, KDE, GTK, Gnome, wxPython และทุก GUI-Toolkit ต่างก็เป็น GUI-Toolkit ที่มีประสิทธิภาพทั้งสิ้น
• Ruby : : ความเป็นภาษาใหม่ของ Ruby ทำให้ Ruby ยังมี GUI ให้ใช้ไม่มากนัก แต่ไม่นานครับ ตอนนี้นักพัฒนาโปรแกรมของ Ruby ต่างเร่งผลิต Toolkit เหล่านี้ให้เราใช้งานอยู่ อีกสองสามปี ผมคิดว่า GUI ของ Ruby คงเทียบชั้น Python ได้ไม่ยาก

Round 9 : ETC.

• Java : : เนื่องจาก Java เป็นภาษาที่เขียนยาก แต่มีคนใช้เยอะ เลยมี IDE ดี ๆ ให้เลือกใช้งานหลากหลายตามไปด้วย สองผู้นำในวงการ IDE ของ Java ได้แก่ NetBeans และ Ecipse ซึ่งทั้งสองเป็น IDE ที่มีคุณภาพสูง แถมทั้งคู่เป็น OpenSource อีกต่างหาก นอกจาก IDE แล้ว Java ยังมีเครื่องมืออื่น ๆ ให้เลือกใช้อย่างจุใจ
• Python : : IDLE เป็นเครื่องมือมาตรฐานที่ติดตัวมากับ Python อันประกอบด้วย Editor และ Interactive-Python ซึ่งเป็นเครื่องมือที่เหมาะสำหรับงานขั้นพื้นฐานเท่านั้น แม้ว่า Python จะเป็นภาษาที่ค่อนข้างได้รับความนิยม แต่ถือว่ามีเครื่องมือจำพวก IDE ให้เลือกใช้งานน้อยมาก
• Ruby : : ความเป็นน้องใหม่ของ Ruby ทำให้ Ruby เสียเปรียบในหลาย ๆ ด้าน ไม่เว้นแม้แต่ด้านเครื่องมือการพัฒนาโปรแกรม โดยส่วนตัวผมคิดว่า ในอนาคตเราก็อาจไม่มีเครื่องมืออลังการอย่าง NetBeans หรือ Eclipse สำหรับ Ruby หรือ Python มาใช้งานกัน เพราะคุณสมบัติของภาษา Script ทำให้เครื่องมือต่าง เป็นเพียงเครื่องอำนวยความสดวก มากกว่าเครื่องมือจำเป็น

• Java : : คอนเซพท์ Write once run any where ของ Java นั้น ถือเป็นนวรรตกรรมบรรลือโลก ที่ถึงตอนนี้ยังไม่มีใครมาเทียบรัศมี (.NET ฟังดูดี แต่ในความเป็นจริงมันงี่เง่า เพราะใช้งานได้เฉพาะ OS ความหวังจึงน่าจะอยู่ที่ Mono) Byte-Code ที่ได้ไม่ต้องเปลี่ยนแปลงใด ๆ ก็ใช้งานได้ทุก OS ดังนั้นเรื่อง Plattform ต้องยกให้ Java เขาไป
• Python : : แม้ว่า Python จะรองรับหลาย OS ไม่แพ้ Java แต่โค้ดบางส่วน ก็ต้องมีการแก้ไขเพื่อให้เข้ากับ OS โดยเฉพาะในส่วนที่ใช้ Module os ของ Python อีกทั้งการนำไปใช้งาน ก็เป็นการนำซอร์สโค้ดไปใช้ ไม่ได้เป็น Byte-Code อย่าง Java
• Ruby : : เหมือน Python ครับ :P

Round 10 : Performance

Platform

Computer-Modell : Notebook Samsung R55

CPU : Intel Core 2 Duo Centrino T5500

CPU-Freq : 1830 MHz

RAM : 1 GB

OS : Ubuntu 6.04 LTS

Java-1.4 : gij (GNU libgcj) version 4.1.0 (Ubuntu 4.1.0-1ubuntu8)

Java-1.6 : Java(TM) SE Runtime Environment (build 1.6.0-b105)

Python : Python 2.4.3 (#2, Oct 6 2006, 07:52:30) , [GCC 4.0.3 (Ubuntu 4.0.3-1ubuntu5)] on linux2

Ruby : ruby 1.8.4 (2005-12-24) [i486-linux]

หมายเหตุ สำหรับ Java ให้ยึด Java 1.6 เป็นหลักครับ เพราะ Java ของ GNU มันไม่ดีเท่า Java 1.6 ของ Sun แต่สูสี Java 1.4 ของค่ายอื่น ๆ อยู่ (แต่จากการคาดการณ์ ผมคิดว่าคนส่วนใหญ่ยังใช้ Java 1.4 อยู่นะ)

Speed

Memory-usage

public class test {
    public static void main(String[] args) {
        for (int i = 0; i < 1000000; i++) {
            System.out.println(i);
        }
    }
}

for x in range(1000000):
    print x

1000000.times do |i|
	puts i
end

import java.util.*;
 
public class test {
	public static void main(String[] args) {
		for (int i = 0; i < 6000; i++) {
			Map x = new HashMap();
			for (int j = 0; j < 1000; j++) {
				Integer I=new Integer(i);
				Integer J=new Integer(j);
				x.put(J,I);
				x.get(J);
			}
		}
	}
}

for i in range(6000):
    x={}
    for j in range(1000):
        x[j]=i
        x[j]

6000.times do |i|
	x={}
	1000.times do |j|
		x[j] = i
		x[j]
	end
end

import java.io.*;
 
public class test
{
	public static void main(String[] args) {
		try {
			File f = new File("/tmp/scratch");
		PrintWriter pw= new PrintWriter(
				new BufferedWriter(
				new FileWriter(f)));
			for (int i = 0; i < 1000000; i++) {
				pw.print(i);
			}
			pw.close();
		}
		catch(IOException ioe) {
			ioe.printStackTrace();
		}
	}
}

f=open('/tmp/scratch','wb')
for i in xrange(1000000):
    f.write(str(i))
f.close()

f = File.new("/tmp/scratch", "w")
1000000.times do |i|
	f.syswrite(i.to_s)
end
f.close

import java.util.*;
 
public class test {
    public static void main(String[] args) {
	List initial = new ArrayList();
	initial.add("a");
	initial.add("b");
	initial.add("c");
	initial.add("d");
	initial.add("e");
	initial.add("f");
	initial.add("g");
 
        for (int i = 0; i < 3000; i++) {
            List v = new ArrayList(initial);
            for (int j = 0; j < 1000; j++) {
                v.add(new Integer(j));
                v.get(j);
            }
        }
    }
}

a = map(lambda x : ['a','b','c','d','e','f','g']+range(1000),range(3000))
for i in a : i

3000.times do |i|
	v=['a','b','c','d','e','f','g']
	1000.times do |j|
		v.push(j)
		v[j]
	end
end

import java.lang.Math;
 
public class test {
	public static void main(String[] args) {
		double[] x       = new double[200000];
		double[] gauss   = new double[200000];
		double[] laplace = new double[200000];
		double[] si      = new double[200000];
		double[] sisqr   = new double[200000];
		double[] bp      = new double[200000];
		for(int i = 0 ; i < 200000; i++){
			x[i]       = (i/10000.0)-10.0;
			gauss[i]   = Math.exp(-1.0 * x[i] * x[i]);
			laplace[i] = Math.exp(-1.0 * Math.abs(x[i]));
			si[i]      = Math.sin(x[i]*Math.PI)/(x[i]*Math.PI);
			sisqr[i]   = si[i]*si[i];
			bp[i]      = si[i]*Math.cos(x[i]*100);
		}
	}
}

import numpy
x = numpy.arange(-10,10,0.0001)
gauss   = numpy.exp(-(x**2))
laplace = numpy.exp(-numpy.abs(x))
si      = numpy.sin(x*numpy.pi)/(numpy.pi)
sisqr   = si**2
bp      = si*numpy.cos(x*100)

x = []
gauss = []
laplace = []
si = []
sisqr = []
bp = []
200000.times do |i|
	x.push( (i / 10000.0)-10.0 )
	gauss.push( Math.exp(-1.0 * x[i] * x[i]) )
	laplace.push(Math.exp(-1.0 * x[i].abs ))
	si.push(Math.sin(x[i]* Math::PI) / (x[i] * Math::PI))
	sisqr.push(si[i]*si[i])
	bp.push(si[i]*Math.cos(x[i]*100))
end