หากสามารถสร้างบางสิ่งได้สิ่งนั้นก็คือข้อมูลไม่ใช่รหัส

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

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

หากกำลังทำการเชื่อมต่อสองภาษาแสดงว่าฟังดูเหมือนขาดส่วนต่อประสานไลบรารี

ฉันทำอะไรบางอย่างหายไปหรือเปล่า

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

การสร้างซอร์สโค้ดเป็นรูปแบบการต่อต้านหรือไม่?

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

หากสามารถสร้างบางสิ่งได้มากกว่าสิ่งนั้นคือข้อมูลไม่ใช่รหัส

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

โปรเซสเซอร์ประมวลผลคำสั่งออกจากหน่วยความจำ หน่วยความจำเดียวกันที่ใช้สำหรับข้อมูล ก่อนที่จะประมวลผลรันคำสั่งโปรแกรมที่ถูกโหลดลงในหน่วยความจำที่เป็นข้อมูล

ดังนั้นทุกอย่างเป็นข้อมูลรหัสแม้กระทั่ง

เนื่องจากว่า [รหัสที่สร้างขึ้นคือข้อมูล] ความคิดทั้งหมดของการสร้างรหัสนี้ไม่ถูกต้องหรือไม่

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

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

นั่นเป็นวิธีหนึ่ง แต่มีคนอื่น ๆ

ผลลัพธ์ของการสร้างรหัสคือข้อความซึ่งเป็นสิ่งที่ออกแบบมาเพื่อใช้โดยมนุษย์

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

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

การใช้เหตุผลเชิงปฏิบัติ

ตกลงฉันรู้ว่ารหัสนั้นเป็นข้อมูลเช่นกัน สิ่งที่ฉันไม่เข้าใจคือทำไมสร้างรหัสต้นฉบับ

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

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

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

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

เปรียบเทียบสิ่งนี้กับภาษาที่มีไดนามิกมากเช่น Ruby ซึ่งฉันจะพิจารณาสิ่งที่ตรงกันข้ามกับ Java ในแง่ส่วนใหญ่ (โปรดทราบว่าฉันกำลังพูดถึงสิ่งนี้โดยไม่ให้คุณค่ากับวิธีการใดวิธีหนึ่ง; นี่คือปกติและมาตรฐาน 100% ในการสร้างคลาส, วิธีการและอื่น ๆ ที่รันไทม์, และที่สำคัญที่สุด, โปรแกรมเมอร์สามารถทำอย่างถูกต้องในโค้ดโดยไม่ต้องไปถึงระดับ "เมตาดาต้า" ใช่สิ่งต่าง ๆ เช่น Ruby on Rails มาพร้อมกับการสร้างรหัส แต่เราพบว่าในงานของเรานั้นเราใช้มันเป็น "โหมดการสอน" ขั้นสูงสำหรับโปรแกรมเมอร์ใหม่ แต่หลังจากนั้นไม่นานมันก็ไม่จำเป็น เพื่อเขียนในระบบนิเวศนั้นว่าเมื่อคุณรู้ว่าคุณกำลังทำอะไรการเขียนด้วยตนเองจะได้เร็วกว่าการล้างโค้ดที่สร้างขึ้น)

นี่เป็นเพียงตัวอย่างการปฏิบัติสองอย่างจาก "โลกแห่งความจริง" จากนั้นคุณมีภาษาเช่น LISP ที่รหัสเป็นข้อมูลตัวอักษร ในทางกลับกันในภาษาที่คอมไพล์ (ไม่มีเอ็นจิ้นรันไทม์เช่น Java หรือ Ruby) มี (หรือเคยฉันไม่ได้ติดตามคุณสมบัติ C ++ ที่ทันสมัย ​​... ) เพียงแค่ไม่มีแนวคิดของการกำหนดชื่อคลาสหรือเมธอดที่รันไทม์ ดังนั้นการสร้างรหัสกระบวนการสร้างจึงเป็นเครื่องมือของทางเลือกสำหรับสิ่งส่วนใหญ่ (ตัวอย่างอื่น ๆ เพิ่มเติมเฉพาะ C / C ++ จะเป็นสิ่งต่าง ๆ เช่น flex, yacc เป็นต้น)

สร้างรหัสทำไม

เนื่องจากการเขียนโปรแกรมด้วย punch card (หรือรหัส alt ใน notepad ) เป็นความเจ็บปวด

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

จริง ฉันไม่สนใจเกี่ยวกับการแสดงนอกจากจะถูกบังคับ

หากกำลังทำการเชื่อมต่อสองภาษาแสดงว่าฟังดูเหมือนขาดส่วนต่อประสานไลบรารี

อืมไม่รู้ว่าคุณกำลังพูดถึงอะไร

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

ซึ่งเป็นเรื่องดีจนกระทั่งฉันต้องรักษามัน ณ จุดนี้คุณทุกคนสามารถไปตาย

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

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

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

ทำไมต้องสร้างซอร์สโค้ด

กรณีการใช้งานบ่อยที่สุดสำหรับเครื่องกำเนิดรหัสที่ฉันต้องทำงานด้วยในอาชีพของฉันคือเครื่องกำเนิดไฟฟ้าซึ่ง

• ใช้ meta-description ระดับสูงสำหรับรูปแบบข้อมูลบางส่วนหรือสคีมาฐานข้อมูลเป็นอินพุต (อาจเป็นสคีมาสัมพันธ์หรือสคีมา XML บางชนิด)

• และสร้างรหัส CRUD ของ boiler-plate สำหรับคลาส data access เป็นเอาต์พุตและอาจเป็นสิ่งเพิ่มเติมเช่น SQL หรือเอกสารที่เกี่ยวข้อง

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

ให้ฉันตอบคำถามแรกของคุณด้วย

การสร้างซอร์สโค้ดเป็นรูปแบบการต่อต้าน

ไม่ไม่ใช่การสร้างซอร์สโค้ดต่อ se แต่มีข้อผิดพลาดบางอย่าง ตามที่ระบุในProgrammer ศาสตร์หนึ่งควรหลีกเลี่ยงการใช้งานของเครื่องกำเนิดไฟฟ้ารหัสเมื่อมันผลิตรหัสซึ่งยากที่จะเข้าใจ มิฉะนั้นความพยายามที่เพิ่มขึ้นในการใช้หรือแก้ไขข้อบกพร่องรหัสนี้อาจเกินความพยายามที่บันทึกไว้ได้อย่างง่ายดายโดยไม่ต้องเขียนรหัสด้วยตนเอง

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

ทำไมต้องสร้างซอร์สโค้ด

ฉันพบกรณีการใช้งานสองกรณีสำหรับรหัสที่สร้างขึ้น (ณ เวลาบิลด์และไม่เคยเช็คอิน):

1. สร้างรหัสสำเร็จรูปโดยอัตโนมัติเช่น getters / setters, toString, equals และ hashCode จากภาษาที่สร้างขึ้นเพื่อระบุสิ่งต่าง ๆ (เช่น project lombok สำหรับ Java)
2. สร้างคลาสประเภท DTO โดยอัตโนมัติจากอินเทอร์เฟซบางอย่าง (REST, SOAP, อะไรก็ตาม) เพื่อใช้ในรหัสหลัก สิ่งนี้คล้ายกับปัญหาบริดจ์ภาษาของคุณ แต่จบลงด้วยความสะอาดและเรียบง่ายกว่าด้วยการจัดการชนิดที่ดีกว่าการพยายามใช้สิ่งเดียวกันโดยไม่มีคลาสที่สร้างขึ้น

Sussmann มีความน่าสนใจอย่างมากที่จะพูดเกี่ยวกับสิ่งต่าง ๆ ใน "โครงสร้างและการตีความโปรแกรมคอมพิวเตอร์" แบบคลาสสิกของเขาส่วนใหญ่เกี่ยวกับความเป็นคู่ของรหัสข้อมูล

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

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

โดยการแสดงข้อความที่ถูกป้อนไปยังคอมไพเลอร์ระบบฉันได้รับการปรับแต่งคอมไพเลอร์และการกำหนดค่าเฉพาะของระบบทั้งหมดโดยไม่ต้องคิด

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

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

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

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

แน่นอนคุณสามารถเขียนสิ่งต่าง ๆ เพื่อเอาท์พุท bytecode หรือแม้แต่โค้ดที่สามารถเรียกใช้งานได้ แต่ทำไมคุณถึงทำอย่างนั้น? เรามีเครื่องมือสำหรับการแปลง IR เป็นสิ่งเหล่านั้น

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

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

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

ในขณะเดียวกันถ้าคุณใช้ OpenShadingLanguage: https://github.com/imageworks/OpenShadingLanguage

... ดังนั้นคำถามดังกล่าวไม่จำเป็นต้องถูกยกขึ้นเนื่องจากพวกเขาได้รับคำตอบทันทีจากผลลัพธ์ที่น่าประทับใจ

OSL ใช้เฟรมเวิร์กคอมไพเลอร์ LLVM เพื่อแปลเครือข่าย shader เป็นรหัสเครื่องได้ทันที (ในเวลาหรือ "JIT") และในกระบวนการนั้นจะปรับ shader และเครือข่ายอย่างมากด้วยความรู้เต็มรูปแบบของพารามิเตอร์ shader และค่ารันไทม์อื่น ๆ เป็นที่รู้จักกันเมื่อ shaders ถูกรวบรวมจากซอร์สโค้ด เป็นผลให้เราเห็นเครือข่ายการแรเงา OSL ของเราดำเนินการได้เร็วขึ้น 25% จาก shaders เทียบเท่าที่สร้างขึ้นด้วยมือใน C! (นั่นเป็นวิธีที่ shaders เก่าของเราทำงานในโหมดแสดงภาพของเรา)

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

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

การแยกทางประวัติศาสตร์ของรหัสที่ไม่สามารถอ่านได้กลางมนุษย์

ลองยกตัวอย่าง C และ C ++ เนื่องจากเป็นภาษาที่มีชื่อเสียงที่สุด

คุณควรสังเกตว่าการประมวลผลแบบลอจิคัลของการรวบรวมรหัส C ไม่ใช่รหัสเครื่อง แต่เป็นรหัสแอสเซมบลีที่มนุษย์อ่านได้ ในทำนองเดียวกันคอมไพเลอร์ C ++ เก่าที่ใช้ในการคอมไพล์รหัส C ++ ลงในโค้ด C ในห่วงโซ่ของเหตุการณ์นั้นคุณสามารถรวบรวมจากรหัสที่มนุษย์อ่านได้ 1 ถึงรหัสที่มนุษย์สามารถอ่านได้ 2 ถึงรหัสที่มนุษย์สามารถอ่านได้ 3 ถึงรหัสเครื่อง "ทำไม?" ทำไมจะไม่ล่ะ?

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

เหตุใดจึงต้องใช้รหัสกลางที่มนุษย์อ่านได้

1. บางครั้งต้องการรหัสกลางเพื่อให้คุณสามารถแก้ไขได้ก่อนขั้นตอนต่อไปในการสร้าง ฉันจะยอมรับจุดนี้เป็นจุดอ่อน
2. บางครั้งก็เป็นเพราะงานต้นฉบับไม่ได้ทำในภาษาที่มนุษย์อ่านได้ แต่ในเครื่องมือสร้างแบบจำลอง GUI แทน
3. บางครั้งคุณต้องทำสิ่งที่ซ้ำซ้อนมากและภาษาไม่ควรตอบสนองสิ่งที่คุณทำเพราะเป็นสิ่งเฉพาะหรือสิ่งที่ซับซ้อนที่ไม่มีธุรกิจเพิ่มความซับซ้อนหรือไวยากรณ์ของภาษาโปรแกรมเพียงเพื่อรองรับ คุณ.
4. บางครั้งคุณต้องทำสิ่งที่ซ้ำซ้อนมากและไม่มีวิธีที่เป็นไปได้ที่จะได้สิ่งที่คุณต้องการเป็นภาษาในลักษณะทั่วไป ไม่สามารถแสดงหรือขัดแย้งกับไวยากรณ์ของภาษา
5. หนึ่งในเป้าหมายของคอมพิวเตอร์คือการลดความพยายามของมนุษย์และบางครั้งรหัสที่ไม่น่าจะได้สัมผัสอีกครั้ง (โอกาสในการบำรุงรักษาต่ำ) อาจมีการเขียน meta-code เพื่อสร้างรหัสที่ยาวขึ้นในเวลา 10 ถ้าผมสามารถทำมันได้ใน 1 วันแทน 2 สัปดาห์ที่ผ่านมาและมันก็ไม่น่าจะได้รับการรักษาที่เคยแล้วฉันดีกว่าสร้างมัน - และในโอกาสปิดที่ใครบางคน 5 ปีนับจากนี้รำคาญเพราะพวกเขาเป็นจริงไม่จำเป็นต้องรักษามันแล้ว พวกเขาสามารถใช้เวลา 2 สัปดาห์ในการเขียนออกมาอย่างเต็มที่หากพวกเขาต้องการหรือรำคาญกับการบำรุงรักษารหัสที่น่าอึดอัดใจ 1 สัปดาห์ (แต่เรายังคงอยู่ 1 สัปดาห์ข้างหน้า ณ จุดนั้น) และนั่นคือถ้าการบำรุงรักษานั้นจำเป็นต้องทำทั้งหมด .
6. ฉันแน่ใจว่ามีเหตุผลมากกว่าที่ฉันมองเห็น

ตัวอย่าง

ฉันทำงานเกี่ยวกับโครงการก่อนที่จะต้องสร้างรหัสขึ้นอยู่กับข้อมูลหรือข้อมูลในเอกสารอื่น ตัวอย่างเช่นโครงการหนึ่งมีข้อความเครือข่ายและข้อมูลคงที่ทั้งหมดที่กำหนดไว้ในสเปรดชีตและเครื่องมือที่จะผ่านสเปรดชีตและสร้างรหัส C ++ และ Java จำนวนมากที่ให้เราทำงานกับข้อความเหล่านั้น

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

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

ตัวอย่างที่ 2

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

ควรจะทำอย่างอื่นได้อย่างไร? บางทีคุณอาจคิดวิธีอื่น อาจมีวิธีอื่น แต่สำหรับงานนั้นวิธีอื่นคงไม่ดีไปกว่าโค้ด lex / parse ที่ฉันสร้างขึ้น

สิ่งที่คุณกำลังขาดหายไปคือนำมาใช้ใหม่

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

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

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

ดังนั้นสมมติว่าคุณต้องการเพิ่มสิ่งอำนวยความสะดวกใหม่เพื่อให้ชีวิตของคุณง่ายขึ้น บางทีมันอาจเป็นเครื่องมือโครงร่าง GUI บางทีมันอาจเป็นอินเทอร์เฟซสัญญาณและสล็อตที่Qtให้ บางทีนี่อาจเป็นวิธีที่Code Composer Studio ของ TIช่วยให้คุณกำหนดค่าอุปกรณ์ที่คุณใช้งานและดึงไลบรารี่ที่ถูกต้องเข้าสู่บิลด์ บางทีมันอาจใช้พจนานุกรมข้อมูลและการพิมพ์อัตโนมัติที่สร้างขึ้นและคำจำกัดความทั่วโลกตัวแปร (ใช่นี้ยังคงเป็นสิ่งที่มากในซอฟต์แวร์ฝังตัว) วิธีใดก็ตามที่มีประสิทธิภาพที่สุดในการใช้ประโยชน์จากคอมไพเลอร์ที่มีอยู่ของคุณคือการสร้างเครื่องมือที่จะใช้การกำหนดค่าของสิ่งที่มันเป็นและผลิตรหัสโดยอัตโนมัติในภาษาที่คุณเลือก

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

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

Interoprability / ความเรียบง่าย

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

การใช้งาน / เหตุผลทางเทคนิค

ใช้ typescript - เบราว์เซอร์ไม่สามารถตีความมันดังนั้นการสร้างกระบวนการใช้transpiler (รหัสรหัสผู้แปล) เพื่อสร้าง JavaScript ในความเป็นจริงภาษาที่รวบรวมใหม่หรือลึกลับมากมายเริ่มต้นด้วยการ transpiling เป็น C ก่อนที่พวกเขาจะได้รับคอมไพเลอร์ที่เหมาะสม

สะดวกในการใช้

สำหรับโครงการฝังตัว (คิดว่า IoT) เขียนใน C และใช้เพียงไบนารีเดียว (RTOS หรือไม่มีระบบปฏิบัติการ) มันค่อนข้างง่ายในการสร้างอาร์เรย์ C ที่มีข้อมูลที่จะรวบรวมราวกับว่าซอร์สโค้ดปกติเหมือนกับที่เชื่อมโยงโดยตรง เป็นทรัพยากร

แก้ไข

การขยายโปรโตบูฟ: การสร้างรหัสช่วยให้วัตถุที่สร้างขึ้นเป็นคลาสชั้นหนึ่งในภาษาใด ๆ ในภาษาที่คอมไพล์โปรแกรมแยกวิเคราะห์ทั่วไปจะส่งคืนโครงสร้างคีย์ - ค่าซึ่งหมายความว่าคุณต้องใช้รหัสสำเร็จรูปมากคุณพลาดการตรวจสอบเวลาคอมไพล์ (บนคีย์และประเภทของค่าโดยเฉพาะ) ประสิทธิภาพแย่ลงและ ไม่มีรหัสให้สมบูรณ์ ลองนึกภาพผู้ที่void*อยู่ใน C หรือใหญ่std::variantใน C ++ (ถ้าคุณมี C ++ 17) บางภาษาอาจไม่มีคุณสมบัติดังกล่าวเลย

การสร้างซอร์สโค้ดเป็นรูปแบบการต่อต้านหรือไม่?

มันเป็นวิธีการทำงานสำหรับภาษาการเขียนโปรแกรมที่แสดงออกไม่เพียงพอ ไม่จำเป็นต้องสร้างรหัสในภาษาที่มีการเขียนโปรแกรมเมตาในตัวที่เพียงพอ

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

อย่างไรก็ตามหากมีการใช้การสร้างซอร์สโค้ดเพื่อแทนที่คุณสมบัติเช่น generics แสดงว่าเป็น anti-pattern

ฉันทำอะไรบางอย่างหายไปหรือเปล่า

อาจเป็นตัวอย่างที่ดีที่รหัสตัวกลางกลายเป็นสาเหตุของความสำเร็จหรือไม่ ฉันสามารถให้ HTML แก่คุณ

ฉันเชื่อว่ามันสำคัญสำหรับ HTML ที่จะง่ายและไม่เปลี่ยนแปลง - ทำให้มันง่ายต่อการสร้างเบราว์เซอร์อนุญาตให้เริ่มต้นเบราว์เซอร์มือถือก่อนเป็นต้นเมื่อมีการทดลองเพิ่มเติม (Java applets, Flash) - ภาษาที่ซับซ้อนและทรงพลัง . ปรากฎว่าผู้ใช้งานได้รับอันตรายจาก Java applets และการเยี่ยมชมเว็บไซต์ดังกล่าวนั้นปลอดภัยพอ ๆ กับการลองเล่นรอยแตกของเกมที่ดาวน์โหลดผ่าน DC ++ ในทางกลับกัน HTML ธรรมดานั้นไม่เป็นอันตรายพอที่จะให้เราตรวจสอบเว็บไซต์ใด ๆ ที่มีความเชื่ออย่างสมเหตุสมผลในเรื่องความปลอดภัยของอุปกรณ์ของเรา

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

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

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

ทำไมต้องสร้างซอร์สโค้ด

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

กรณีการใช้งานทั่วไป:

• เครื่องมือสร้างแบบจำลองเช่น Rose หรือ Visual Paradigm;
• สูงเอ้อภาษาระดับเช่น SQL ฝังตัวหรือภาษานิยามอินเตอร์เฟซที่จะต้องประมวลผลล่วงหน้าเป็นสิ่งที่ compilable;
• เครื่องกำเนิดไฟฟ้า Lexer และ parser เช่น flex / bison;

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

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

ฉันจะรู้สิ่งนี้ได้อย่างไร เพราะมันเป็นวิธีการแก้ปัญหาที่ฉันติดต่อมาหลายครั้งเมื่อทำงานกับระบบที่แตกต่างกันมากที่สุด SourcePawn ล่าสุด สคริปต์ Python แบบง่าย ๆ ที่แยกวิเคราะห์บรรทัดของซอร์สโค้ดและสร้างโค้ดที่สร้างสองหรือสามบรรทัดนั้นดีกว่าการสร้างโค้ดที่สร้างขึ้นด้วยตนเองเมื่อคุณจบด้วยสองโหลเช่นบรรทัด (สร้าง cvars ทั้งหมดของฉัน)

มีซอร์สโค้ดตัวอย่าง / ตัวอย่างถ้าผู้ใช้ต้องการ

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

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

สร้างรหัสเพียงครั้งเดียว

ไม่ใช่การสร้างซอร์สโค้ดทั้งหมดเป็นกรณีของการสร้างโค้ดบางส่วนแล้วไม่ต้องแตะต้องเลย จากนั้นสร้างใหม่จากแหล่งต้นฉบับเมื่อต้องการอัปเดต

บางครั้งคุณสร้างรหัสเพียงครั้งเดียวแล้วละทิ้งแหล่งต้นฉบับแล้วย้ายไปข้างหน้ารักษาแหล่งใหม่

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

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

เครื่องกำเนิดรหัสดังกล่าวมักจะแตกต่างกันมากกับประเภทของเครื่องกำเนิดรหัสที่แปลภาษาเต็มรูปแบบ (เช่น Cython หรือf2c) เนื่องจากเป้าหมายคือการบำรุงรักษาโค้ดหนึ่งครั้ง พวกเขามักจะถูกทำให้เป็น 1 เพื่อทำสิ่งที่พวกเขาต้องทำ ในหลาย ๆ ทางมันเป็นรุ่นต่อไปของการใช้ regex / find-replace ไปยังรหัสพอร์ต "เครื่องมือช่วยพอร์ต" คุณสามารถพูดได้

การสร้างรหัสเพียงครั้งเดียวเช่นจากเว็บไซต์ขูด

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

DataDeps.jl ช่วยให้ผู้ใช้ดาวน์โหลดข้อมูล (เช่นชุดข้อมูล ML มาตรฐาน) ในการทำสิ่งนี้มันต้องการสิ่งที่เราเรียกว่า RegistrationBlock นั่นคือรหัสบางส่วนที่ระบุเมตาดาต้าบางอย่างเช่นตำแหน่งที่จะดาวน์โหลดไฟล์และการตรวจสอบและข้อความที่อธิบายให้ผู้ใช้ทราบถึงข้อตกลง / โค้ด / สิ่งที่สถานะการอนุญาตใช้งานของข้อมูลคืออะไร

การเขียนบล็อกเหล่านั้นอาจสร้างความรำคาญ และข้อมูลนั้นมักมีอยู่ใน (โครงสร้างหรือไม่มีโครงสร้าง) จากเว็บไซต์ที่มีการโฮสต์ข้อมูล ดังนั้น DataDepsGenerators.jl ใช้ webscraper เพื่อสร้าง RegistrationBlockCode สำหรับบางไซต์ที่โฮสต์ข้อมูลจำนวนมาก

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

ที่สำคัญผู้ใช้งาน / dev ที่ทำงานกับ DataDeps.jl ไม่จำเป็นต้องติดตั้งหรือใช้ webscraper เพื่อใช้รหัส RegistrationBlock ที่ถูกสร้างขึ้น (และไม่จำเป็นต้องดาวน์โหลดและติดตั้ง web-scraper ช่วยประหยัดเวลาได้พอสมควรโดยเฉพาะอย่างยิ่งสำหรับ CI ที่รัน)

การสร้างซอร์สโค้ดครั้งเดียวไม่มีปฏิสสาร และโดยปกติจะไม่สามารถแทนที่ด้วย metaprogramming

การสร้างรหัส "source" เป็นการระบุถึงข้อบกพร่องของภาษาที่สร้างขึ้น ใช้เครื่องมือในการเอาชนะรูปแบบการต่อต้านหรือไม่ ไม่อย่างนั้น - ให้ฉันอธิบาย

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

เมื่อฉันเขียน c ++ ฉันทำเช่นนั้นเพราะมันทำให้ฉันสามารถเขียนโค้ดได้มีประสิทธิภาพมากกว่าการใช้แอสเซมเบลอร์หรือรหัสเครื่อง รหัสเครื่องยังคงถูกสร้างโดยคอมไพเลอร์ ในการเริ่มต้น c ++ เป็นเพียงตัวประมวลผลล่วงหน้าที่สร้างรหัส C ภาษาสำหรับวัตถุประสงค์ทั่วไปนั้นยอดเยี่ยมสำหรับการสร้างพฤติกรรมวัตถุประสงค์ทั่วไป

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

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

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

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

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

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

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

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

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

การปิดการค้าที่ไม่ดีอาจเกี่ยวข้องกับปริมาณการใช้ ภาษา A อาจแตกต่างอย่างมากจาก B แต่โครงการทั้งหมดที่มีตัวสร้างโค้ดแบบกำหนดเองใช้เพียง A ในสถานที่เล็ก ๆ แห่งหนึ่งหรือสองแห่งเท่านั้นดังนั้นความซับซ้อนทั้งหมด (บิตเล็ก ๆ ของ A บวกกับตัวสร้างโค้ด A -> B บวกกับการสร้างฉากรอบ) เกินความซับซ้อนของการแก้ปัญหาที่เพิ่งทำใน B.

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

ฉันไม่เห็นสิ่งนี้ชัดเจน (ฉันเห็นคำตอบหนึ่งหรือสองข้อ แต่ดูเหมือนไม่ชัดเจน)

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

การแก้ไขโค้ดที่สร้างขึ้นเป็นหนึ่งในรูปแบบการต่อต้านต่อต้านที่ร้ายกาจและน่ากลัวที่สุดที่คุณเคยเจอ อย่าทำอย่างนี้.

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

ฉันคิดว่าหมวดที่สามคือรหัสที่คุณใช้ครั้งเดียว (ตัวสร้าง gui) แล้วแก้ไขเพื่อช่วยให้คุณเริ่มต้น / เรียนรู้ นี่เป็นของเล็ก ๆ น้อย ๆ - เป็นวิธีที่ดีในการเริ่มต้น แต่ตัวสร้าง GUI ของคุณจะถูกกำหนดเป้าหมายโดยใช้รหัส "Generatable" ซึ่งจะไม่เป็นการเริ่มต้นที่ดีสำหรับคุณในฐานะโปรแกรมเมอร์ - นอกจากนี้คุณอาจจะ ล่อลวงให้ใช้มันอีกครั้งสำหรับ GUI ที่สองซึ่งหมายถึงการดึงรหัส SOURCE ที่ซ้ำซ้อนเข้าสู่ระบบของคุณ

หากเครื่องมือของคุณฉลาดพอที่จะไม่อนุญาตการแก้ไขใด ๆ ของรหัสที่สร้างขึ้นให้ไปหามัน ถ้าไม่ฉันจะเรียกมันว่าหนึ่งในรูปแบบการต่อต้านที่เลวร้ายที่สุดที่นั่น

รหัสและข้อมูลทั้งสองคือ: ข้อมูล

Data เป็นข้อมูลที่ตรงตามรูปแบบที่คุณต้องการ (และมูลค่า) รหัสยังเป็นข้อมูล แต่อยู่ในรูปแบบทางอ้อมหรือระดับกลาง ในสาระสำคัญรหัสยังเป็นรูปแบบของข้อมูล

โดยเฉพาะอย่างยิ่งรหัสคือข้อมูลสำหรับเครื่องเพื่อกำจัดมนุษย์จากการประมวลผลข้อมูลด้วยตนเอง

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

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

สมมติว่ามีคนเสนอฟังก์ชั่นการทำแผนที่ให้คุณซึ่งการใช้งานไม่ชัดเจนสำหรับคุณ ตราบใดที่ฟังก์ชั่นใช้งานได้ตามที่สัญญาไว้คุณจะสนใจหรือไม่ว่ามันเป็นการสร้างรหัสต้นฉบับภายใน

หากสามารถสร้างบางสิ่งได้สิ่งนั้นก็คือข้อมูลไม่ใช่รหัส

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

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

ระบุว่าแนวคิดการสร้างซอร์สโค้ดทั้งหมดนี้ไม่ใช่ความเข้าใจผิดหรือ

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

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

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

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

เช่นเดียวกับเครื่องกำเนิดรหัสระดับสูงที่สุดเช่นกัน กรณีแม่บทอาจจะเป็นสแกนเนอร์และเครื่องกำเนิดไฟฟ้า parser เช่นและlex yaccใช่คุณสามารถเขียนสแกนเนอร์และ parser โดยตรงใน C หรือในภาษาการเขียนโปรแกรมอื่น ๆ ที่คุณเลือก (แม้แต่รหัสเครื่องดิบ) และบางครั้งก็ทำได้ แต่สำหรับปัญหาของความซับซ้อนที่สำคัญใด ๆ การใช้ภาษาระดับสูงพิเศษสำหรับวัตถุประสงค์พิเศษเช่น lex's หรือ yacc's ทำให้โค้ดที่เขียนด้วยมือง่ายต่อการเขียนอ่านและบำรุงรักษา ปกติแล้วจะเล็กกว่ามากเช่นกัน

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

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

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

หากกำลังทำการเชื่อมต่อสองภาษาแสดงว่าฟังดูเหมือนขาดส่วนต่อประสานไลบรารี

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

ฉันทำอะไรบางอย่างหายไปหรือเปล่า

ฉันคิดว่าหลายสิ่งหลายอย่าง

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

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

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

ตอบคำถามในบริบทของความคิดเห็นของคุณ:

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

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

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

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

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

หากเราใช้การสร้างรหัสเราอาจมีความสามารถในการจัดการข้อผิดพลาดที่มีประสิทธิภาพมากกว่าพร้อมกับข้อผิดพลาดที่มนุษย์อ่านได้ C'est la vie

การสร้างรหัสมีวิธีที่ต่างกันสองสามวิธี พวกเขาสามารถแบ่งออกเป็นสามกลุ่มหลัก:

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

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

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

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

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

อาจมีพื้นกลางแม้ว่า: F # รองรับแนวคิดของผู้ให้บริการประเภทซึ่งโดยทั่วไปแล้วอินเตอร์เฟซที่พิมพ์อย่างยิ่งที่สร้างขึ้นโดยทางโปรแกรมในเวลารวบรวม แนวคิดนี้อาจแทนที่การใช้รหัสจำนวนมากและแยกความกังวลออกจากกัน

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

หากสามารถสร้างบางสิ่งได้สิ่งนั้นก็คือข้อมูลไม่ใช่รหัส

คุณเข้าใจผิด ควรอ่าน

หากสิ่งที่สามารถป้อนลงในเครื่องกำเนิดสำหรับแปลได้สิ่งนั้นก็คือรหัสไม่ใช่ข้อมูล

เป็นรูปแบบแหล่งที่มาสำหรับขั้นตอนการรวบรวมนั้นและรูปแบบการซิงค์ยังคงเป็นรหัส