วิธีการจัดระเบียบโปรแกรม R ขนาดใหญ่?

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

มีวิธีปฏิบัติอะไรบ้างที่ฉันสามารถปรับใช้เพื่อให้รหัสของฉันมีความสุขที่ได้ทำงานด้วยเสมอ ฉันคิดเกี่ยวกับสิ่งที่ชอบ

• การวางตำแหน่งของฟังก์ชั่นในไฟล์ต้นฉบับ
• เมื่อจะทำลายบางสิ่งบางอย่างออกไปยังแฟ้มแหล่งอื่น
• สิ่งที่ควรจะอยู่ในแฟ้มต้นแบบ
• การใช้ฟังก์ชั่นเป็นหน่วยขององค์กร (ไม่ว่าจะเป็นสิ่งที่คุ้มค่าหรือไม่เพราะ R ทำให้ยากต่อการเข้าถึงสถานะส่วนกลาง)
• การฝึกการเยื้อง / การแบ่งบรรทัด
  • ปฏิบัติต่อ (เช่น {?
  • ใส่สิ่งที่ชอบ)} ใน 1 หรือ 2 บรรทัด?

โดยทั่วไปแล้วกฎข้อง่ายๆในการจัดการสคริปต์ R ขนาดใหญ่คืออะไร?

คำตอบมาตรฐานคือการใช้แพ็กเกจ - ดูคู่มือการเขียนส่วนต่อขยาย Rรวมทั้งบทช่วยสอนต่าง ๆ บนเว็บ

มันให้คุณ

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

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

ในฐานะที่เป็นส่วนหนึ่งของ 'วิธีการแก้ไข' ที่R Internalsคู่มือมียอดเยี่ยมR มาตรฐานการเข้ารหัสในมาตรา 6 มิฉะนั้นผมมีแนวโน้มที่จะใช้ค่าเริ่มต้นในโหมด ESS Emacs'

ปรับปรุง 2008 ส.ค. 13: เดวิดสมิ ธ เพียง blogged เกี่ยวกับคู่มือสไตล์ Google R

ฉันชอบใส่ฟังก์ชั่นที่แตกต่างในไฟล์ของตัวเอง

แต่ฉันไม่ชอบระบบแพ็คเกจของ R มันค่อนข้างใช้งานยาก

ฉันชอบทางเลือกที่มีน้ำหนักเบาเพื่อวางฟังก์ชั่นของไฟล์ไว้ในสภาพแวดล้อม (สิ่งที่ภาษาอื่น ๆ เรียกว่า "namespace") และแนบมัน ตัวอย่างเช่นฉันสร้างกลุ่ม 'util' ของฟังก์ชั่นดังนี้:

util = new.env()

util$bgrep = function [...]

util$timeit = function [...]

while("util" %in% search())
  detach("util")
attach(util)

นี่คือทั้งหมดในแฟ้มutil.R เมื่อคุณมามันคุณจะได้รับสภาพแวดล้อม 'util' เพื่อให้คุณสามารถโทรutil$bgrep()และเช่น; แต่ยิ่งไปกว่านั้นการattach()โทรทำให้เป็นเช่นนั้นbgrep()และทำงานได้โดยตรง หากคุณไม่ได้ใส่ฟังก์ชั่นเหล่านั้นไว้ในสภาพแวดล้อมของตัวเองพวกเขาอาจทำให้เนมสเปซระดับบนสุดของล่าม (สิ่งที่ls()แสดง)

ฉันพยายามจำลองระบบของ Python ที่ทุกไฟล์เป็นโมดูล จะดีกว่าที่จะมี แต่ดูเหมือนว่าตกลง

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

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

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

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

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

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

ฉันเห็นด้วยกับคำแนะนำ Dirk! IMHO การจัดระเบียบโปรแกรมของคุณจากสคริปต์ง่าย ๆ ไปจนถึงแพ็คเกจเอกสารสำหรับการเขียนโปรแกรมใน R เช่นการสลับจาก Word เป็น TeX / LaTeX สำหรับการเขียน ฉันขอแนะนำให้ดูที่การสร้างแพ็คเกจ R ที่มีประโยชน์มาก: บทแนะนำโดย Friedrich Leisch

คำตอบที่กระชับของฉัน:

1. เขียนฟังก์ชั่นของคุณอย่างถี่ถ้วนเพื่อระบุเอาต์พุตและอินพุตทั่วไปที่เพียงพอ
2. จำกัด การใช้ตัวแปรโกลบอล
3. ใช้วัตถุ S3 และตามความเหมาะสมวัตถุ S4;
4. ใส่ฟังก์ชั่นในแพ็คเกจโดยเฉพาะเมื่อฟังก์ชั่นของคุณโทรหา C / Fortran

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

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

บรรทัดของรหัสต่อไปนี้จะสร้างสภาพแวดล้อมที่ชื่อว่า "myfuncs" บนเส้นทางการค้นหาหากยังไม่มีอยู่ (โดยใช้ไฟล์แนบ) และเติมด้วยฟังก์ชั่นที่มีอยู่ในไฟล์. r ในไดเรกทอรี 'functions /' ของฉัน (โดยใช้ sys.source) ฉันมักจะวางบรรทัดเหล่านี้ไว้ที่ด้านบนสุดของสคริปต์หลักของฉันซึ่งมีไว้สำหรับ "ส่วนต่อประสานผู้ใช้" ซึ่งเรียกฟังก์ชั่นระดับสูง (เรียกใช้ฟังก์ชั่นระดับต่ำ)

if( length(grep("^myfuncs$",search()))==0 )
  attach("myfuncs",pos=2)
for( f in list.files("functions","\\.r$",full=TRUE) )
  sys.source(f,pos.to.env(grep("^myfuncs$",search())))

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

evalq(f <- function(x) x * 2, pos.to.env(grep("^myfuncs$",search())))

เพื่อประเมินการเพิ่ม / การดัดแปลงในสภาพแวดล้อมที่คุณสร้างขึ้น

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

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

http://www1.maths.lth.se/help/R/RCC/

มี "อนุสัญญา" อื่น ๆ เกี่ยวกับการใช้ [, drop = FALSE] และ <- ตามที่โอเปอเรเตอร์มอบหมายที่แนะนำในงานนำเสนอต่าง ๆ (โดยปกติคือคำปราศรัย) ที่ useR! การประชุม แต่ฉันไม่คิดว่าสิ่งเหล่านี้จะเข้มงวด (แม้ว่า [, drop = FALSE] จะเป็นประโยชน์สำหรับโปรแกรมที่คุณไม่แน่ใจเกี่ยวกับข้อมูลที่คุณคาดหวัง)

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

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

สำหรับการเข้าถึงสภาพแวดล้อมทั่วโลกนั้นทำได้ง่ายด้วยตัวดำเนินการ << แม้ว่ามันจะหมดกำลังใจ

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

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

บันทึก. rsuiteผมไม่ได้เป็นผู้สร้างหรือพัฒนาของ

1. เราทำโปรเจคผิดกับ RStudio ทั้งหมด เป้าหมายไม่ควรเป็นการสร้างโครงการหรือแพ็คเกจ แต่มีขอบเขตที่ใหญ่กว่า ใน rsuite คุณสร้างโครงการ super-project หรือโครงการต้นแบบซึ่งถือโครงการ R มาตรฐานและแพคเกจ R ในการรวมกันเป็นไปได้ทั้งหมด

2. การมีโปรเจค Super R คุณไม่จำเป็นต้องใช้ Unix อีกต่อไปmakeเพื่อจัดการโปรเจ็กต์ R ระดับล่างที่อยู่ด้านล่าง คุณใช้สคริปต์ R ที่ด้านบน ให้ผมแสดง. เมื่อคุณสร้างโครงการต้นแบบ rsuite คุณจะได้รับโครงสร้างโฟลเดอร์นี้:

3. โฟลเดอร์ที่คุณวางสคริปต์การจัดการโครงการของคุณคนที่จะเข้ามาแทนที่Rmake

4. โฟลเดอร์packagesเป็นโฟลเดอร์ที่rsuiteเก็บบรรจุภัณฑ์ทั้งหมดที่ประกอบเป็นโครงการซุปเปอร์ คุณยังสามารถคัดลอกวางแพคเกจที่ไม่สามารถเข้าถึงได้จากอินเทอร์เน็ตและ rsuite ก็จะสร้างมันขึ้นมาเช่นกัน

5. โฟลเดอร์deploymentคือตำแหน่งที่rsuiteจะเขียนไบนารีแพคเกจทั้งหมดที่ระบุในDESCRIPTIONไฟล์แพ็คเกจ ดังนั้นสิ่งนี้ทำให้คุณคาดการณ์เวลาของ Accros ที่ทำซ้ำได้ทั้งหมด

6. rsuiteมาพร้อมกับไคลเอนต์สำหรับระบบปฏิบัติการทั้งหมด ฉันได้ทดสอบพวกเขาทั้งหมด แต่คุณสามารถติดตั้งเพื่อใช้เป็นaddinRStudio ได้

7. rsuiteนอกจากนี้ยังช่วยให้คุณสามารถสร้างแยกการติดตั้งในโฟลเดอร์ของตัวเองconda condaนี่ไม่ใช่สภาพแวดล้อม แต่เป็นการติดตั้ง Python แบบฟิสิคัลที่ได้รับจาก Anaconda ในเครื่องของคุณ สิ่งนี้ทำงานร่วมกับ R's SystemRequirementsซึ่งคุณสามารถติดตั้งแพ็กเกจ Python ทั้งหมดที่คุณต้องการจากช่อง conda ที่คุณต้องการ

8. คุณยังสามารถสร้างที่เก็บในเครื่องเพื่อดึงแพ็คเกจ R เมื่อคุณออฟไลน์หรือต้องการสร้างสิ่งทั้งหมดได้เร็วขึ้น

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

10. อีกทางเลือกหนึ่งคือการสร้างที่เก็บของโครงการทั้งหมดใน Ubuntu, Debian หรือ CentOS ดังนั้นแทนที่จะแชร์ไฟล์ zip กับบิลด์โครงการของคุณคุณแชร์Dockerคอนเทนเนอร์ทั้งหมดกับโปรเจ็กต์ของคุณพร้อมที่จะทำงาน

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

สิ่งแรกที่ฉันเริ่มทดลองคือกับbookdownebooks ฉันไม่เคยโชคดีพอที่จะมีหนังสือเล่มหนึ่งเพื่อเอาชีวิตรอดจากการทดสอบนานกว่าหกเดือน ดังนั้นสิ่งที่ฉันทำคือแปลงโปรเจค bookdown ดั้งเดิมให้เป็นไปตามrsuiteกรอบ ตอนนี้ฉันไม่ต้องกังวลกับการปรับปรุงสภาพแวดล้อม R ทั่วโลกของฉันเพราะโครงการมีชุดของตัวเองในdeploymentโฟลเดอร์

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

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

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

ฉันคาดหวังว่าวันหนึ่งRStudioจะช่วยให้เราสามารถสร้างโครงการการเตรียมการเช่นเดียวกับrsuiteจากเมนู มันจะยอดเยี่ยม

ลิงค์:

RSuite GitHUb repo

r4ds bookdown

keras และกวดวิชามันวาว

moderndive-book-rsuite

interpretable_ml-rsuite

IntroMachineLearningWithR-rsuite

clark-intro_ml-rsuite

Hyndman-bookdown-rsuite

statistical_rethinking-rsuite

fread-มาตรฐาน-rsuite

DataViz-rsuite

การค้าปลีกการแบ่งส่วน-H2O-กวดวิชา

Telco-ลูกค้าปั่น-กวดวิชา

sclerotinia_rsuite

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