ทำไมความกระตือรือร้นในปัจจุบันสำหรับ Function Programming? [ปิด]

ฉันได้รับความกระตือรือร้นอย่างมากเกี่ยวกับภาษาการเขียนโปรแกรมที่ใช้งานได้เมื่อไม่นานมานี้เกี่ยวกับ Scala, Clojure และ F # ฉันเพิ่งเริ่มเรียน Haskell เพื่อเรียนรู้กระบวนทัศน์ของ FP

ฉันรักมันสนุกจริงๆและเหมาะกับพื้นหลังคณิตศาสตร์ของฉัน

แต่มันจะสำคัญหรือไม่ เห็นได้ชัดว่ามันเป็นความคิดใหม่แทบจะไม่

นี่คือคำถามของฉัน:

1. อะไรเป็นสาเหตุของความกระตือรือร้นของ FP เมื่อเร็ว ๆ นี้? เป็นเพียงความเบื่อหน่ายกับ OO หรือมีบางสิ่งบางอย่างเปลี่ยนไปเพื่อให้ FP ต้องการมากกว่าเดิมหรือไม่?
2. สิ่งนี้บ่งบอกถึงอนาคตของ FP หรือไม่ หรือนี่คือแฟชั่นเช่นฐานข้อมูล Object Object หรือไม่

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

หนึ่งในนวัตกรรมสำคัญของ FP ที่ส่งผลให้เกิด "การระเบิด" ที่น่าสนใจคือพระ

ในเดือนมกราคมปี 1992 ฟิลิปวาเดลเลอร์เขียนบทความที่เรียกว่าThe Essence of Functional Programmingซึ่งนำ monads มาใช้ในการเขียนโปรแกรมเชิงปฏิบัติการเพื่อจัดการกับ IO

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

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

พระสงฆ์จะแก้ปัญหาของ IO ได้อย่างไร ดีโดยไม่พูดถึงพระมากเกินไปโดยทั่วไปพวกเขาใช้ "โลก" (สภาพแวดล้อมรันไทม์) เป็นอินพุตไปยัง monad และสร้าง "โลก" ใหม่เป็นเอาท์พุทและผลลัพธ์: พิมพ์ IO a = World -> (a, โลก).

FP ได้เข้าสู่กระแสหลักมากขึ้นเรื่อย ๆ เนื่องจากปัญหาที่ใหญ่ที่สุด IO (และอื่น ๆ ) ได้รับการแก้ไข การรวมเข้ากับภาษา OO ที่มีอยู่ก็เกิดขึ้นอย่างที่คุณรู้ LINQ คือ monads ตัวอย่างเช่น through and through

สำหรับข้อมูลเพิ่มเติมฉันแนะนำให้อ่านเรื่อง monads และเอกสารอ้างอิงในคำตอบของฉัน

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

ตัวอย่าง: ในการทำ A คุณต้องมี B และ C และ B ขึ้นอยู่กับ D และ E ส่งผลให้มีลักษณะดังนี้

• D
• E
• C
• B
• A

เพราะคุณต้องเตรียมส่วนผสมก่อนจึงจะสามารถใช้มันได้

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

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

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

ในช่วงปลายยุค 80 / ต้นยุค 90 คอมพิวเตอร์มีพลังเพียงพอสำหรับ OOP แบบ Smalltalk คอมพิวเตอร์ทุกวันนี้มีพลังเพียงพอสำหรับ FP FP คือการเขียนโปรแกรมในระดับที่สูงกว่าและบ่อยครั้ง - ในขณะที่พอใจในการเขียนโปรแกรม - ไม่ใช่วิธีที่มีประสิทธิภาพที่สุดในการแก้ปัญหาบางอย่าง แต่คอมพิวเตอร์นั้นเร็วมากจนคุณไม่สนใจ

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

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

ความต้องการในปัจจุบันสำหรับการคำนวณแบบกระจาย

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

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

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

การถือกำเนิดของ FP (และ NoSQL ในระดับหนึ่ง) มาหลังจากเรื่องราวเกี่ยวกับผลลัพธ์การคำนวณที่น่าทึ่งในคอมพิวเตอร์นับแสนที่ทำงานพร้อมกันและมันง่ายเพียงใด

แต่นี่อาจเป็นเพียงแอปพลิเคชั่นที่ต้องการการตั้งค่าประเภทนี้ สำหรับแอพพลิเคชั่น / ระบบอื่น ๆ มากมายขั้นตอนและ OO นั้นใช้ได้ผลดี

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

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

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

นี่เป็นเพียงหนึ่งในเหตุผล แต่เป็นเหตุผลที่ดีสำหรับการดูการทำงานของโปรแกรม

ฉันคิดว่าคำตอบหลักของคำถามนั้นคือ 'เปิดเผย'

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

เมื่อไม่นานมานี้มีหลายภาษาที่ได้รับความสนใจในกระแสหลักที่ใช้วิธีการหลายกระบวนทัศน์ F # , JavaScript เป็นตัวอย่างที่ดีเยี่ยม

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

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

เมื่อ F # กลายเป็นภาษาชั้นหนึ่งใน Visual Studio 2010 และ jQuery (และคณะ) กลายเป็นสิ่งสำคัญดังนั้นจึงกลายเป็นเรื่องจริงที่จะใช้ภาษาเหล่านี้มากกว่าที่จะคลุมเครือที่จะเล่นกับหรือสร้างโปรแกรมแยก

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

ในการพูดคุยนี้ Anders Hejlsberg อธิบายมุมมองของเขาในหัวข้อ

[แก้ไข]

ขออภัยลิงค์นี้ผิด ตอนนี้มันชี้ไปยังสถานที่ที่เหมาะสม

สรุปสั้น ๆ บางจุดของการสนทนาหนึ่งชั่วโมง:

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

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

ฉันคิดว่ามันเกี่ยวข้องกับความสัมพันธ์ที่ใกล้ชิดระหว่างกระบวนทัศน์การเขียนโปรแกรมการใช้งานและการเขียนโปรแกรมสำหรับเว็บ

Ruby on Rails นำวิธีการเขียนโปรแกรมการทำงานทั้งหมดมาใช้เพื่อบรรเทาความคมชัดเนื่องจากเป็นเส้นทางที่รวดเร็วมากในการใช้งานเว็บ (heh heh) แอปพลิเคชัน มีการอภิปรายที่น่าสนใจเกี่ยวกับเรื่องนี้และคำตอบอย่างหนึ่งที่โดดเด่นคือ:

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

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

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

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

ฉันรู้ว่า FP ไม่ใช่แนวคิดใหม่ในตอนนี้ แต่ก็ไม่ใช่ทั้ง OO เมื่อมันถูกทำลายลงอย่างแท้จริงในยุคเมื่อ "ทุกคน" จู่ ๆ ก็กระโดดจากการเขียนโปรแกรมตามขั้นตอน นี่เป็นส่วนใหญ่เนื่องจากความสำเร็จของ Java และ C # ในเวลาต่อมา

ฉันคิดว่าสิ่งเดียวกันนี้จะเกิดขึ้นกับ FP ในที่สุดเมื่อภาษาชุดถัดไปเริ่มแพร่กระจายในลักษณะเดียวกัน อย่างน้อยก็ในบางแวดวงที่มีภาษาอย่าง Scala และ F #

นี่คือคำถามของฉัน: 1. อะไรเป็นสาเหตุของความกระตือรือร้นของ FP เมื่อเร็ว ๆ นี้? เป็นเพียงความเบื่อหน่ายกับ OO หรือมีบางสิ่งบางอย่างเปลี่ยนไปเพื่อให้ FP ต้องการมากกว่าเดิมหรือไม่? 2. สิ่งนี้บ่งบอกถึงอนาคตของ FP หรือไม่ หรือนี่คือแฟชั่นเช่นฐานข้อมูล Object Object หรือไม่

คนอื่น ๆ ให้เหตุผลทางเทคนิคที่ดี

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

อนาคตจะมีการใช้อย่างแพร่หลายหากสัญญาเป็นจริงและเป็นจริง

ฉันคิดว่ามันเป็นการรวมกันของสองแนวโน้ม:

1. เพิ่มฟังก์ชั่นการใช้งานในภาษาหลัก (เช่น C #)
2. มีการสร้างภาษาที่ใช้งานได้ใหม่

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

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

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

มันเรียบร้อยและดีและทำให้สมองคุณแย่ ไม่เป็นไร.

มันยัง IMHO, bandwagon คลาสสิก วิธีการแก้ปัญหาที่กำลังมองหาปัญหา

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

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

แน่นอนเพราะ F # ถึงแม้ว่าบางครั้งมันก็ยากที่จะบอกว่าอันไหนเป็นต้นเหตุและอันไหนเป็นผล