ฟังก์ชั่นการเขียนโปรแกรมที่เพิ่มขึ้น?

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

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

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

ฉันเห็นด้วยความสนใจอย่างมากความจริงที่ว่าแม้ว่าพวกเขาจะไม่ได้รับการยอมรับจากชุมชนอย่างมีนัยสำคัญ แต่ภาษาประเภทนี้ก็ยังปรากฏขึ้นเรื่อย ๆ Clojure (2007), Scala (2003), F # (2002) เป็นเพียงตัวอย่างของทศวรรษที่ผ่านมา

ฉันเคยลงทุนกับการเรียนรู้ Haskell และ Scala บ้างแล้ว และฉันพบศักยภาพที่ยอดเยี่ยมในกระบวนทัศน์ซึ่งสำหรับฉันใหม่แม้จะอยู่ที่นั่นนานมาก

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

สิ่งที่ฉันต้องการถามคือ:

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

คำแนะนำใด ๆ สำหรับการวิจัยเพิ่มเติมจะยินดีมากกว่า

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

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

ขอบคุณล่วงหน้า!

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

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

เป็นหลัก "ปัญหาสเปรดชีต" คุณมีข้อมูลเริ่มต้นและชุดการคำนวณแบบแถวต่อแถวเพื่อนำไปใช้กับข้อมูลนั้น

แอปพลิเคชั่นการผลิตของเราทำข้อมูลสรุปทางสถิติจำนวนหนึ่ง นี่คือทั้งหมดเข้าหาที่ดีที่สุดตามหน้าที่

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

แอปพลิเคชั่นเขียนด้วย Python แต่เขียนในรูปแบบการใช้งานโดยใช้ฟังก์ชั่นเครื่องกำเนิดไฟฟ้าและ tuples ชื่อไม่เปลี่ยนรูป มันเป็นองค์ประกอบของฟังก์ชั่นระดับล่าง

นี่คือตัวอย่างที่ชัดเจนขององค์ประกอบการทำงาน

for line in ( l.split(":") for l in ( l.strip() for l in someFile ) ):
    print line[0], line[3]

นี่เป็นวิธีหนึ่งที่การเขียนโปรแกรมการทำงานมีผลต่อภาษาเช่น Python

บางครั้งสิ่งประเภทนี้ได้รับการเขียนเป็น:

cleaned = ( l.strip() for l in someFile )
split = ( l.split(":") for l in cleaned )
for line in split:
     print line[0], line[3]

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

วัตถุที่ไม่เปลี่ยนรูปนั้นเป็นสิ่งกีดขวางที่ยากที่สุด

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

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

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

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

ฉันได้อ่าน Haskell เพื่อทำความเข้าใจกับสิ่งที่หลามขาดไป

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

การเปลี่ยนไม่ได้

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

ทำหน้าที่เป็นประเภทเฟิร์สคลาส

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

ความสามารถในการเขียนฟังก์ชั่น (ตัวอย่างเช่นการเปลี่ยนAction<T>เป็นเพียงแค่Actionยังมีประโยชน์มากในบางสถานการณ์

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

monads

เป็นที่ยอมรับว่าเป็นจุดอ่อนของฉัน แต่ความเข้าใจของฉันคือเวิร์กโฟลว์การคำนวณใน F # เช่นasyncเวิร์กโฟลว์เป็น monad นี่เป็นโครงสร้างที่บอบบาง แต่ทรงพลังมาก มันมีประสิทธิภาพเท่ากับyieldคำสำคัญที่ใช้ในการสร้างIEnumerableคลาสใน C # โดยพื้นฐานแล้วมันกำลังสร้างเครื่องสถานะสำหรับคุณภายใต้ฝาครอบ แต่ตรรกะของคุณดูเป็นเส้นตรง

การประเมินผลและการเรียกซ้ำขี้เกียจ

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

S-นิพจน์

ฉันเดาว่าฉันไม่แน่ใจว่าจะวางที่ใด แต่ความสามารถในการจัดการโค้ดที่ไม่ได้คอมไพล์เป็นวัตถุ (และตรวจสอบ / แก้ไข) เช่น Lisp S-Expressions หรือ LINQ Expression ในบางวิธี เครื่องมือที่ทรงพลังที่สุดของการเขียนโปรแกรมการทำงาน อินเทอร์เฟซใหม่ "คล่องแคล่ว". NET และ DSLs ส่วนใหญ่ใช้การรวมกันของ lambda syntax และ LINQ Expressions เพื่อสร้าง API ที่รัดกุมมาก ไม่ต้องพูดถึง Linq2Sql / Linq2Nhibernate โดยที่โค้ด C # ของคุณถูกเรียกใช้งาน "magically" เป็น SQL แทนที่จะเป็นโค้ด C #

นั่นเป็นคำตอบที่ยาวนานสำหรับคำถามแรกของคุณ ... ตอนนี้ ...

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

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

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

หากคุณคุ้นเคยกับ. NET ฉันขอแนะนำ F # ในทางตรงกันข้ามถ้าคุณคุ้นเคยกับ JVM ที่มีอยู่เสมอClojure หากคุณเป็นนักวิชาการมากกว่าภาคปฏิบัติฉันจะไปกับ Common LISP หรือ Scheme หากคุณรู้จัก Python อยู่แล้วฉันเชื่อว่ามีการสร้างฟังก์ชั่นมากมายที่มีอยู่แล้ว

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

สิ่งนี้จะเป็นจริงถ้าคุณนับจำนวนโปรแกรมที่พัฒนาโดยโปรแกรมเมอร์มืออาชีพ ถ้าคุณกระจายเครือข่ายของคุณให้กว้างขึ้นเพื่อรวมโปรแกรมที่พัฒนาโดยผู้ที่ไม่ได้พิจารณาตัวเองเช่นนั้น FP (หรืออย่างน้อยการเขียนโปรแกรมในรูปแบบการทำงาน) ก็ค่อนข้างใกล้เคียงกับ OO (Excel, Mathematica, Matlab, R ... )

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

ความเห็นส่วนตัวของฉันคือมัลติคอร์ไม่ใช่ฟีเจอร์นักฆ่าของ FP (อย่างน้อยก็จนกว่า Haskell, Scala, Clojure, คอมไพเลอร์ F # แก้ปัญหาแคชในท้องที่) คุณสมบัตินักฆ่าคือmap, filter, foldและเพื่อน ๆ ที่ช่วยให้การแสดงออกรวบรัดมากขึ้นของคนกลุ่มใหญ่ของอัลกอริทึม สิ่งนี้ประกอบไปด้วยภาษา FP ที่มีไวยากรณ์ที่กระชับกว่า OO ที่นิยมมากที่สุด

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

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

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

• ขาดการสนับสนุนเครื่องมือ (F # และ Lisps บางตัวเป็นข้อยกเว้น Scala กำลังดำเนินการอยู่)
• ยากกว่าที่จะบีบเอาบิตสุดท้ายของประสิทธิภาพออกจากฮาร์ดแวร์ของคุณ
• ชุมชนมักจะมุ่งเน้นไปที่ปัญหาที่แตกต่างกว่าที่ต้องเผชิญกับโครงการพัฒนาซอฟต์แวร์เชิงพาณิชย์กลุ่มใหญ่
• นักพัฒนาน้อยมากที่มีประสบการณ์ในการใช้ FP ในการตั้งค่าอุตสาหกรรมและหากคุณสามารถค้นหาพวกเขาคุณอาจต้องแข่งขันกับเงินเดือนและผลประโยชน์ที่อุตสาหกรรมการเงินสามารถเสนอได้
• รูปแบบการทำงานของโปรแกรมมิงนั้นยากที่จะทำการดีบัก คือการสังเกตระหว่างผลลัพธ์ในสายยาวของฟังก์ชั่นที่สงบมักจะไม่สามารถทำได้ใน debuggers (all?) ส่วนใหญ่

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

• คุณสามารถแก้ไขปัญหาของคุณได้กี่ปัญหาโดยการออกจากห้องสมุด / กรอบงานที่แพลตฟอร์ม (เช่น JVM หรือ. Net) มีจำนวนเท่าไร มีภาษาที่สร้างความสามารถในการแสดงปัญหาเหล่านี้โดยตรงหรือไม่

• คุณต้องการการควบคุมระดับต่ำเพียงใดในการใช้พื้นที่และเวลาในใบสมัครของคุณ?

• ข้อกำหนด "ความถูกต้อง" ของคุณเข้มงวดแค่ไหน?

• คุณสามารถที่จะฝึกอบรมนักพัฒนาและ / หรือแข่งขันกับผลประโยชน์ที่เสนอโดย niches ที่ทำกำไรได้สูงในการพัฒนา SW หรือไม่?

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

สมมติว่าคุณเป็น C ++ / C # / Java dev ในอุตสาหกรรม ...

เตรียมพร้อมสำหรับคนที่ไม่พอใจที่ไม่ต้องการเรียนรู้อะไร เตรียมพร้อมสำหรับหัวหน้าที่มีผมแหลมเลือกใช้ภาษาที่ไม่ดี "เพราะพวกเขาเป็น coder ครั้งเดียว" เตรียมตัวให้พร้อมสำหรับนักวิชาการที่มีสาระเกี่ยวกับฟอรัมที่คอยช่วยเหลือคุณเกี่ยวกับ monoids เตรียมตัวให้พร้อมสำหรับสงครามทางภาษาที่ไม่สิ้นสุดเพราะ Scala ไม่มีแม้แต่การกำจัดหางและ Clojure จำเป็นต้องใช้แป้นเหยียบสำหรับวงเล็บทั้งหมดและไม่ให้ฉันเริ่มต้นกับ Erlang

หากคุณเป็นโปรแกรมเมอร์เว็บแล้วหลุมพรางที่ใหญ่ที่สุดอาจจะเป็นผมของคุณ

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

ฉันจะเริ่มต้นด้วยแพลตฟอร์ม:

• OCaml นั้นยอดเยี่ยมบน Linux และอันยิ่งใหญ่บน Windows
• F # นั้นยอดเยี่ยมสำหรับ Windows และยอดเยี่ยมบน Linux
• Scala และ Clojure นั้นยอดเยี่ยมสำหรับ JVM

สำหรับ (ลำเอียงยอมรับ) หนึ่งมุมมองเกี่ยวกับคำถามนี้คุณอาจตรวจสอบบล็อกบ๊อบฮาร์เปอร์, อัตถิภาวนิยมประเภท Carnegie Mellon เพิ่งปรับปรุงหลักสูตร CS ของพวกเขาเพื่อสอนการเขียนโปรแกรมฟังก์ชั่นก่อนโดยมีกระบวนทัศน์อื่น ๆ ที่ได้รับการสอนเพียงครั้งเดียวเมื่อมีการวางรากฐานของการเขียนโปรแกรมการทำงานที่มั่นคง .

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

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

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

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

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

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

ในบรรดาภาษาการเขียนโปรแกรมที่ฉันรู้ฉันจะพูดได้ว่า Haskell and Clean เท่านั้นที่สามารถเรียกได้ว่าเป็นภาษาที่ใช้งานได้ ผลกระทบอื่น ๆ ทั้งหมดอนุญาตให้มีผลข้างเคียงโดยไม่ทำให้ผลกระทบเหล่านั้นชัดเจนในระบบพิมพ์ ดังนั้นหากคุณจะอุทิศเวลาในการเรียนรู้การเขียนโปรแกรมฟังก์ชั่น Haskell น่าจะเป็นโปรแกรมเดียวที่เหมาะสมกับใบเสร็จ ทั้งหมดที่ฉันรู้ Erlang, Scala, Clojure ฯลฯ เพียงแค่ให้ abstractions การทำงานด้านบนของภาษาที่จำเป็น ดังนั้นหากคุณต้องการเข้าใกล้กระบวนทัศน์การทำงานเป็นบิตแล้วฉันขอแนะนำ Scala หรือ Erlang และถ้าคุณต้องการจัดการทุกอย่างในคราวเดียวและอาจล้มเลิกไปด้วยความหงุดหงิดคุณควรไปกับ Haskell

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

แก้ไข: เนื่องจากไม่ชัดเจนสำหรับทุกคน

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

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

ตัวอย่างของ FP ที่ใช้สำหรับการขนาน:

• CouchDB - สร้างบน Erlang
• การแชทบน Facebook - สร้างบน Erlang
• Twitter - ส่วนใหญ่สร้างบน Scala