ทำไมจึงไม่ใช้จาวาเป็นภาษาสำหรับสร้าง?

หาก Java เป็นภาษาที่ใช้โดยทั่วไปและการสร้างโปรแกรมเป็นสิ่งที่สามารถอธิบายได้โดยใช้ภาษา Java ทำไมจึงไม่ใช่วิธีที่ดีที่สุดในการเขียนไฟล์บิลด์และเราใช้เครื่องมือเช่น Ant, Maven และ Gradle แทน มันจะไม่ตรงไปตรงมามากกว่านี้และยังไม่จำเป็นต้องเรียนรู้ภาษาการเขียนโปรแกรมอีกด้วย (BTW - คำถามนี้สามารถใช้ได้กับภาษาอื่นเช่น C #)

เครื่องมือเฉพาะสำหรับวัตถุประสงค์เฉพาะ

• การใช้คำฟุ่มเฟื่อย

  ภาษาที่ใช้โดยทั่วไปนั้นมักจะเกินไป ถ้าฉันต้องจัดการงานสร้างใน Java ฉันจะรู้สึกหดหู่อย่างรวดเร็วด้วยขนาดของสัตว์ร้าย อย่างไรก็ตามสามารถจัดการได้อย่างง่ายดายโดยใช้ DSL ที่เขียนด้วย Java และในระดับหนึ่งนั่นคือวิธีที่คุณเห็น Gradle (สำหรับ Groovy) และ Buildr (สำหรับ Ruby)

• ความยาก

  ภาษาสำหรับวัตถุประสงค์ทั่วไปนั้นยาก ฉันไม่คิดว่าการเขียนโปรแกรมเป็นเรื่องยากและไม่สามารถรับได้โดยทุกคน แต่ประเด็นคือวิศวกรสร้างของคุณไม่จำเป็นต้องเป็นโปรแกรมเมอร์

• วัตถุประสงค์

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

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

  คุณไม่ต้องการอีกมาก

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

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

เดี๋ยวก่อนเราต้องการเครื่องมือจริงๆหรือ

คำถามที่เกี่ยวข้องอีกข้อหนึ่งคือเราต้องการเครื่องมือสร้างหรือไม่ ความจริงที่ว่าพวกเขามีอยู่ในทุกภาษาเป็นสัญญาณว่าพวกเขาเติมเต็มช่องว่างที่ไม่ควรแม้แต่จะมีในครั้งแรก?

บางภาษาไม่จำเป็นต้องใช้เครื่องมือสร้าง ตัวอย่างเช่นภาษาสคริปต์ส่วนใหญ่ไม่จำเป็นต้องใช้และแก้ปัญหาในเวลาโหลด หรือใช้ Go ซึ่งคอมไพเลอร์จะจัดการทุกอย่างให้คุณซึ่งเป็นข้อแตกต่างที่ดี: ถ้าหากคอมไพเลอร์อย่าง gcc ไม่ต้องการธงหลาย ๆ อันตัวเชื่อมโยงและ makefile จะตายทุกอย่างด้วยกัน? หรือถ้า javac ไม่ต้องการ build.xml หรือ pom.xml เพื่อบอกเขาว่าต้องทำอย่างไร? การจัดการการพึ่งพาไม่ควรเป็นส่วนหนึ่งของเครื่องมือของภาษาโดยตรงเนื่องจากการพึ่งพาเป็นส่วนหนึ่งของโปรแกรมสุดท้าย

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

ฉันไม่คิดว่าภาษาที่คุณใช้สร้างโปรแกรมเป็นปัญหา เป็นภาษาที่คุณใช้ในการเขียนโปรแกรมและแพลตฟอร์มหลักและเครื่องมือที่สำคัญและเรายังคงดำเนินการต่อไป

โดยส่วนตัวแล้วฉันใช้ make / gmake / autotools / pmk และมีความสุขกับพวกเขาสำหรับ C และฉันเริ่มต้นด้วย Java เมื่อสิ่งที่เราได้ทำแล้วมดและตอนนี้ฉันมักจะเลือก Maven มากกว่าทางเลือกเหล่านี้ทั้งหมด แม้ว่าฉันจะเห็นคุณค่าในระดับ gradle buildr และอื่น ๆ แต่ฉันชอบความแพร่หลายของ maven จนถึงการเปลี่ยนแปลงที่สำคัญมากขึ้นเกิดขึ้น รวมทั้งฉันชอบที่มันแข็ง แต่ก็ยังทำให้คุณมีความสามารถในการแก้ไขหากจำเป็น นั่นไม่ใช่เรื่องง่ายเป็นสิ่งที่ดี

มันเป็นเครื่องมือสร้าง เพียงเรียนรู้ที่จะยอมรับและไม่ต่อสู้ มันเป็นการต่อสู้ที่พ่ายแพ้ หรืออย่างน้อยก็นานมาก ๆ

Javaเป็นความจำเป็นภาษาAnt, Mavenฯลฯ เป็นที่เปิดเผยภาษา:

เราสามารถนิยามความแตกต่างได้ดังนี้:

• การเขียนโปรแกรมที่จำเป็น: บอก "เครื่องจักร" ว่าจะทำอะไรและผลลัพธ์ที่คุณต้องการจะเกิดขึ้นคืออะไร
• การโปรแกรมเชิงประกาศ: บอก "เครื่องจักร" ในสิ่งที่คุณต้องการจะเกิดขึ้นและให้คอมพิวเตอร์หาวิธีการทำ ¹

บิวด์ภาษาบอกผู้สร้างว่าควรทำอะไรจากที่ที่ควรนำมา ฯลฯ เครื่องยนต์ที่รันบิลด์ (ซึ่งเขียนด้วยภาษาที่จำเป็นเช่น @ElliottFrisch สังเกต) อ่านคำแนะนำเหล่านี้และทำให้สำเร็จ

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

หากคุณดูที่คุณสมบัติของระบบบิลด์ทั่วไปคุณจะพบ:

1. ข้อมูลมากมาย: ชื่อสวิตช์การตั้งค่ารายการกำหนดค่าสตริง ฯลฯ
2. มีปฏิสัมพันธ์กับสภาพแวดล้อมมากมาย: คำสั่งตัวแปรสภาพแวดล้อม
3. "เครื่องมือสร้าง" ที่ค่อนข้างตรงไปตรงมาในการจัดการการพึ่งพาการทำเกลียวการบันทึก ฯลฯ

หากคุณกำหนดให้เขียนชุดไฟล์บิลด์โดยใช้ภาษาบางภาษา (Java / C # / Python / ฯลฯ ) โดยการทำซ้ำครั้งที่สามหรือครั้งที่สี่คุณต้องชำระ (ก) การรักษาข้อมูลส่วนใหญ่และคำสั่งภายนอกเป็นข้อมูล เช่น XML (b) เขียน "เครื่องมือสร้าง" ในภาษาที่คุณชื่นชอบ

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

กล่าวอีกนัยหนึ่งคุณจะจบด้วย Make หรือ Ant หรือ Rake หรือ MsBuild ภาษาที่จำเป็นสำหรับสิ่งที่ทำได้ดีและโครงสร้างข้อมูลเพื่ออธิบายสิ่งที่คุณต้องการทำซึ่งโดยปกติจะเป็น XML

จำนวนปัจจัยนับรวมกับการใช้ Java / C ++ / C # ในกรณีเหล่านี้

ประการแรกคุณจะต้องรวบรวมสคริปต์สร้างของคุณก่อนจึงจะสามารถเรียกใช้เพื่อสร้างแอปของคุณ คุณจะระบุแพ็คเกจ, แฟล็ก, เวอร์ชันคอมไพเลอร์, พา ธ เครื่องมือที่จำเป็นในการสร้างสคริปต์บิลด์อย่างไร แน่นอนว่าคุณสามารถหาวิธีที่อยู่รอบ ๆ ได้ แต่มันตรงไปตรงมามากกว่าที่จะมีภาษาที่ไม่ต้องการขั้นตอนการสร้าง (เช่นไพ ธ อน) หรือภาษาที่เครื่องมือสร้างของคุณเข้าใจ

ประการที่สองการสร้างไฟล์นั้นเป็นข้อมูลที่หนักในขณะที่ Java / C ++ / C # นั้นเน้นไปที่การเขียนโค้ดและอัลกอริทึม Java และเพื่อน ๆ ไม่มีข้อมูลที่ชัดเจนที่คุณต้องการจัดเก็บ

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

แน่นอน! ทำไมไม่ใช้ภาษาที่ทรงพลังและมีความหมายสำหรับปัญหาที่ซับซ้อนกว่าคนอื่น ๆ ในตอนแรกคิดว่า? โดยเฉพาะอย่างยิ่งเมื่อคนที่ประสบปัญหามีความสามารถในการใช้ภาษาดังกล่าว (การสร้างเป็นปัญหาของโปรแกรมเมอร์และแก้ไขได้ดีที่สุดโดยโปรแกรมเมอร์)

ฉันถามตัวเองด้วยคำถามนี้เมื่อหลายปีก่อนและตัดสินใจว่า Java เป็นภาษาที่ดีสำหรับการกำหนดงานสร้างโดยเฉพาะอย่างยิ่งสำหรับโครงการ Java และด้วยเหตุนี้ฉันจึงเริ่มทำบางสิ่งเกี่ยวกับมัน

การปฏิเสธความรับผิด : ในคำตอบนี้ฉันส่งเสริมiwantระบบสร้างที่ฉันกำลังพัฒนา แต่เนื่องจากนี่เป็นการสนทนาที่แสดงความเห็นต่อไปฉันแน่ใจว่ามันใช้ได้

ฉันจะไม่ทำอย่างละเอียดเกี่ยวกับประโยชน์ของ Java (พลังและความหมาย) หรือ iwant โดยเฉพาะ หากคุณสนใจคุณสามารถอ่านเพิ่มเติมเกี่ยวกับหน้า Iwant

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

"Java มีความจำเป็น แต่การ build นั้นถูกกำหนดไว้อย่างดีที่สุดในวิธีการประกาศ"พวกเขาอาจพูดว่า

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

JacocoTargetsOfJavaModules.with()
    .jacocoWithDeps(jacoco(), modules.asmAll.mainArtifact())
    .antJars(TestedIwantDependencies.antJar(),
            TestedIwantDependencies.antLauncherJar())
    .modules(interestingModules).end().jacocoReport(name)

นี้เป็นตัวอย่างจริงจากโครงการสาธิต Iwant

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

"Java เป็น verbose"

ใช่โค้ด Java มากมายมี verbose แต่มันไม่ใช่ภาษามันเป็นวิธีการใช้งานของคุณ หากการใช้งานเป็น verbose เพียงแค็ปซูลมันอยู่ข้างหลังเป็นนามธรรมที่ดี GPL จำนวนมากมีกลไกที่เพียงพอสำหรับสิ่งนี้

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

(ฉันรู้ว่าการเปรียบเทียบกับ XML เปรียบเสมือนการรับขนมจากเด็ก แต่การสร้างจำนวนมากเกิดขึ้นเพื่อกำหนดใน XML)

"คุณต้องคอมไพล์สคริปต์บิลด์ของคุณ"

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

"Java มีสำเร็จรูป"

จริง คุณต้องนำเข้าคลาสคุณต้องพูดถึง "สาธารณะ" "คลาส" และอื่น ๆ และนี่คือ DSL ภายนอกที่เรียบง่ายทำคะแนนชนะได้ง่าย

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

แต่หลายโครงการต้องการมากกว่าการรวบรวมรายงานความครอบคลุมและบรรจุภัณฑ์ หากสำเร็จรูปของ Java เป็นที่ยอมรับสำหรับปัญหาของลูกค้าทำไมไม่สร้างปัญหา? ทำรองเท้าสำหรับเด็กคนอื่นเท่านั้นทำไม?

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

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