คำถามติดแท็ก functional-programming

ตกลงดังนั้นชื่อเรื่องนั้นเป็นเรื่อง clickbaity เล็ก ๆ น้อย ๆ แต่อย่างจริงจังฉันได้รับการบอกไม่ต้องถามสักครู่ ฉันชอบที่มันส่งเสริมวิธีการที่จะใช้เป็นข้อความในแบบเชิงวัตถุจริง แต่นี่เป็นปัญหาที่จู้จี้ที่คร่ำครวญในหัวของฉัน ฉันสงสัยว่ารหัสที่เขียนได้ดีสามารถปฏิบัติตามหลักการ OO และหลักการทำงานได้ในเวลาเดียวกัน returnฉันพยายามที่จะกระทบความคิดเหล่านี้และจุดเกาะใหญ่ที่ผมเคยมีที่ดินบน ฟังก์ชั่นบริสุทธิ์มีสองคุณสมบัติ: การเรียกซ้ำ ๆ ด้วยอินพุตเดียวกันจะให้ผลลัพธ์เดียวกันเสมอ นี่ก็หมายความว่ามันไม่เปลี่ยนรูป สถานะของมันถูกตั้งค่าเพียงครั้งเดียว มันไม่มีผลข้างเคียง การเปลี่ยนแปลงเพียงอย่างเดียวที่เกิดจากการเรียกมันคือการสร้างผลลัพธ์ ดังนั้นวิธีการอย่างใดอย่างหนึ่งเกี่ยวกับการทำงานอย่างหมดจดถ้าคุณได้สาบานว่าจะใช้returnเป็นวิธีการสื่อสารผลลัพธ์ของคุณ? บอกไม่ได้ถามผลงานความคิดโดยใช้สิ่งที่บางคนจะพิจารณาผลข้างเคียง เมื่อฉันจัดการกับวัตถุฉันไม่ถามเกี่ยวกับสถานะภายในของวัตถุนั้น ฉันบอกสิ่งที่ฉันต้องทำและใช้สถานะภายในเพื่อหาว่าจะทำอย่างไรกับสิ่งที่ฉันบอกให้ทำ เมื่อฉันบอกมันฉันไม่ได้ถามว่ามันทำอะไร ฉันแค่หวังว่ามันจะทำอะไรบางอย่างเกี่ยวกับสิ่งที่มันถูกบอกให้ทำ ฉันคิดว่า Tell, Don't Ask เป็นมากกว่าชื่อที่แตกต่างกันสำหรับการห่อหุ้ม เมื่อฉันใช้returnฉันไม่มีความคิดในสิ่งที่เรียกว่าฉัน ฉันไม่สามารถพูดได้ว่าเป็นโปรโตคอลฉันต้องบังคับให้จัดการกับโปรโตคอลของฉัน ซึ่งในหลายกรณีได้รับการแสดงออกเป็นสถานะภายใน แม้ว่าสิ่งที่ได้รับการเปิดเผยไม่ได้ระบุอย่างชัดเจน แต่โดยทั่วไปแล้วการคำนวณบางอย่างที่ทำกับสถานะและอินพุต args มีอินเทอร์เฟซสำหรับการตอบสนองผ่านกำบังโอกาสที่จะนวดผลลัพธ์เป็นสิ่งที่มีความหมายมากกว่าสถานะภายในหรือการคำนวณ นั่นคือข้อความผ่าน ดูตัวอย่างนี้ ย้อนกลับไปในวันที่เมื่อดิสก์ไดรฟ์มีดิสก์อยู่ในนั้นและไดรฟ์หัวแม่มือคือสิ่งที่คุณทำในรถเมื่อล้อเย็นเกินไปที่จะสัมผัสด้วยนิ้วมือของคุณฉันได้รับการสอนว่าคนที่น่ารำคาญพิจารณาฟังก์ชั่น void swap(int *first, int *second)ดูเหมือนมีประโยชน์มาก แต่เราได้รับการสนับสนุนให้เขียนฟังก์ชันที่ส่งคืนผลลัพธ์ ดังนั้นฉันจึงใส่ใจเรื่องความเชื่อและเริ่มติดตามมัน แต่ตอนนี้ฉันเห็นผู้คนกำลังสร้างสถาปัตยกรรมที่วัตถุให้วิธีที่พวกเขาสร้างการควบคุมที่พวกเขาส่งผลลัพธ์ของพวกเขา …

45 object-oriented  architecture  functional-programming  side-effect 

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

43 functional-programming  haskell  type-systems 

กรณี : ฉันทำงานที่ บริษัท เขียนแอปพลิเคชันใน Python ที่จัดการข้อมูลจำนวนมากในอาร์เรย์ ฉันเป็นผู้พัฒนาโปรแกรมนี้เพียงคนเดียวในขณะนี้ แต่อาจมีการใช้ / แก้ไข / เพิ่มเติมในอนาคต (1-3 ปี) โดยโปรแกรมเมอร์คนอื่น ๆ ในขณะนี้ที่ฉันไม่รู้จัก ฉันอาจจะไม่ได้อยู่ที่นั่นเพื่อช่วยเหลือโดยตรง แต่อาจให้การสนับสนุนผ่านอีเมลหากฉันมีเวลา ดังนั้นในฐานะนักพัฒนาซอฟต์แวร์ที่ได้เรียนรู้การทำงานของโปรแกรม (Haskell) ฉันมักจะแก้ปัญหาเช่นกรองเช่นนี้: filtered = filter(lambda item: included(item.time, dur), measures) ส่วนที่เหลือของรหัสคือ OO เป็นเพียงกรณีเล็ก ๆ ที่ฉันต้องการแก้ปัญหาแบบนี้เพราะมันง่ายกว่าและสวยงามกว่าตามที่ฉันบอก คำถาม : วันนี้การเขียนโค้ดเป็นแบบนี้หรือไม่ นักพัฒนาซอฟต์แวร์ที่ไม่ได้เขียน / เรียนรู้ FP ตอบสนองต่อรหัสเช่นนี้อย่างไร มันอ่านได้หรือไม่ สามารถปรับเปลี่ยนได้? ฉันควรเขียนเอกสารเช่นอธิบายให้เด็กฟังว่าเส้นทำอะไร? # Filter out the …

43 python  functional-programming  software  company 

ฉันยุ่งกับภาษาการเขียนโปรแกรมที่ใช้งานได้ไม่กี่ปีที่ผ่านมาและฉันก็พบกับวลีนี้ ตัวอย่างเช่นมันเป็นบทของ "The Little Schemer ซึ่งแน่นอนว่าบล็อกนี้มีมาก่อนชื่อนี้ (ไม่บทไม่ได้ช่วยตอบคำถามของฉัน) ฉันเข้าใจความหมายของแลมบ์ดาความคิดของฟังก์ชั่นนิรนามนั้นเรียบง่ายและทรงพลัง แต่ฉันไม่เข้าใจว่า "ที่สุด" หมายถึงอะไรในบริบทนี้ สถานที่ที่ฉันได้เห็นวลีนี้: ชื่อของบทที่ 8 ของ The Little Schemer บล็อก: http://lambda-the-ultimate.org/ ชุดเอกสาร "แลมบ์ดาสุดยอด X": http://library.readscheme.org/page1.html ฉันรู้สึกว่าฉันไม่มีข้อมูลอ้างอิงที่นี่ใครช่วยได้บ้าง

43 functional-programming  terminology  history  lambda 

สมมติว่าเรามีฟังก์ชั่นบริสุทธิ์ปกติเช่น function add(a, b) { return a + b } จากนั้นเราก็ดัดแปลงมันโดยที่มันมีผลข้างเคียง function add(a, b) { writeToDatabase(Math.random()) return a + b; } มันไม่ถือว่าเป็นฟังก์ชั่นที่บริสุทธิ์เท่าที่ฉันรู้เพราะฉันมักจะได้ยินคนเรียกฟังก์ชั่นที่บริสุทธิ์ว่า "ฟังก์ชั่นที่ไม่มีผลข้างเคียง" อย่างไรก็ตามมันจะทำตัวเหมือนฟังก์ชั่นแท้ๆเท่าที่ความจริงที่ว่ามันจะคืนค่าเอาต์พุตเดียวกันสำหรับอินพุตเดียวกัน มีชื่อที่แตกต่างกันสำหรับฟังก์ชั่นประเภทนี้มันไม่มีชื่อหรือมันยังบริสุทธิ์อยู่และฉันเข้าใจผิดเกี่ยวกับคำนิยามของความบริสุทธิ์หรือไม่?

43 functional-programming  side-effect  pure-function 

ฉันถูกเรียกดูผ่าน Amazon.com ร้านหนังสือและฉันมาข้ามหนังสือ"หน้าที่ Programming สำหรับ Java Developers" ฉันรู้ว่าการเขียนโปรแกรมฟังก์ชั่นพื้นฐานบางอย่างและได้รับการเขียนโปรแกรมใน Java เป็นเวลา 3 ปี ฉันต้องการที่จะรู้ว่าฟังก์ชั่นการเขียนโปรแกรมเป็นไปได้แม้ใน Java?

42 java  functional-programming 

ฉันได้สังเกตเห็นเมื่อเร็ว ๆ นี้ว่าภาษาเขียนโปรแกรมการทำงานได้รับความนิยม ฉันเพิ่งเห็นว่าดัชนี Tiobeแสดงให้เห็นถึงความนิยมที่เพิ่มขึ้นเมื่อเทียบกับปีที่แล้วถึงแม้ว่าส่วนใหญ่ของพวกเขาจะไม่ถึง 50 อันดับแรกของภาษายอดนิยมตามดัชนีนี้ และนี่เป็นกรณีที่ค่อนข้างนาน ฟังก์ชั่นการตั้งโปรแกรมไม่ได้กลายเป็นที่นิยมเท่ารุ่นอื่น ๆ (เช่นการเขียนโปรแกรมเชิงวัตถุ) ฉันได้เห็นความสนใจที่เกิดขึ้นใหม่ในพลังของการเขียนโปรแกรมฟังก์ชั่นอย่างไรก็ตามและตอนนี้มัลติคอร์ได้รับความนิยมเพิ่มขึ้นเรื่อย ๆ นักพัฒนาได้เริ่มแสดงความสนใจในรูปแบบอื่น ๆ ที่เกิดขึ้นพร้อมกัน ฉันเห็นด้วยความสนใจอย่างมากความจริงที่ว่าแม้ว่าพวกเขาจะไม่ได้รับการยอมรับจากชุมชนอย่างมีนัยสำคัญ แต่ภาษาประเภทนี้ก็ยังปรากฏขึ้นเรื่อย ๆ Clojure (2007), Scala (2003), F # (2002) เป็นเพียงตัวอย่างของทศวรรษที่ผ่านมา ฉันเคยลงทุนกับการเรียนรู้ Haskell และ Scala บ้างแล้ว และฉันพบศักยภาพที่ยอดเยี่ยมในกระบวนทัศน์ซึ่งสำหรับฉันใหม่แม้จะอยู่ที่นั่นนานมาก และแน่นอนคำถามที่ยิ่งใหญ่ที่สุดของฉันคือถ้าสิ่งเหล่านี้จะได้รับความนิยมมากพอที่จะพิจารณาใช้ความพยายามใด ๆ ในพวกเขา แต่นี่เป็นคำถามที่ไม่แม้แต่แมนเดรคก็สามารถตอบได้ สิ่งที่ฉันต้องการถามคือ: ในสถานการณ์ใดที่ฉันควรพิจารณาภาษาการเขียนโปรแกรมที่ใช้งานได้ดีกว่าที่เหมาะสมในการทำงานที่ได้รับ? นอกเหนือจากปัญหามัลติคอร์ที่ได้รับความนิยมเมื่อเร็ว ๆ นี้ของการเขียนโปรแกรมแบบขนาน หากฉันตัดสินใจเปลี่ยนเป็นภาษาโปรแกรมที่ใช้งานได้ซึ่งคุณจะพิจารณาว่าเป็นข้อผิดพลาดที่ใหญ่ที่สุดที่ฉันจะต้องเผชิญ (นอกจากการเปลี่ยนกระบวนทัศน์และความยากลำบากในการประเมินประสิทธิภาพเนื่องจากการประเมินที่ขี้เกียจ) ด้วยภาษาการเขียนโปรแกรมที่ใช้งานได้มากมายคุณจะเลือกภาษาที่เหมาะสมกับความต้องการของคุณได้อย่างไร คำแนะนำใด ๆ สำหรับการวิจัยเพิ่มเติมจะยินดีมากกว่า ฉันได้ค้นหาความคิดเห็นจากเว็บและดูเหมือนว่าความนิยมที่ได้รับการต่ออายุทั้งหมดนี้มาจากแนวคิดที่ว่าตอนนี้เรากำลังเข้ามาถึงกำแพงของกฎของมัวร์และภาษาการเขียนโปรแกรมที่ใช้งานได้จะมาช่วยเรา แต่ถ้าเป็นกรณีนี้ฉันจะบอกว่ามีความน่าจะเป็นของภาษายอดนิยมที่มีอยู่ในปัจจุบันปรับตัวเข้ากับกระบวนทัศน์ …

42 programming-languages  functional-programming 

TL; DR: ภาษาที่ใช้งานได้จัดการการเรียกซ้ำได้ดีกว่าภาษาที่ไม่ทำงานหรือไม่ ขณะนี้ฉันกำลังอ่าน Code Complete 2 ในบางช่วงของหนังสือผู้แต่งเตือนเราเกี่ยวกับการเรียกซ้ำ เขาบอกว่าควรหลีกเลี่ยงเมื่อเป็นไปได้และฟังก์ชั่นที่ใช้การเรียกซ้ำโดยทั่วไปมีประสิทธิภาพน้อยกว่าโซลูชันที่ใช้ลูป ตัวอย่างผู้เขียนเขียนฟังก์ชัน Java โดยใช้การเรียกซ้ำเพื่อคำนวณแฟกทอเรียลของตัวเลขเช่นนั้น (อาจไม่เหมือนกันทั้งหมดเนื่องจากฉันไม่มีหนังสือกับฉันในขณะนี้): public int factorial(int x) { if (x <= 0) return 1; else return x * factorial(x - 1); } นี่เป็นวิธีแก้ปัญหาที่ไม่ดี อย่างไรก็ตามในภาษาที่ใช้งานได้การใช้การเรียกซ้ำเป็นวิธีที่นิยมใช้ในการทำสิ่งต่างๆ ตัวอย่างเช่นนี่คือฟังก์ชันแฟกทอเรียลใน Haskell โดยใช้การเรียกซ้ำ: factorial :: Integer -> Integer factorial 0 = 1 factorial n = n …

41 functional-programming  recursion 

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

41 functional-programming 

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

41 functional-programming  solid 

ปัจจุบันฉันใช้รหัสกับ C, C ++ และ Python ฉันต้องการรับภาษาโปรแกรมที่ใช้งานได้และตอนนี้ฉันกำลังโน้มตัวไปหา Haskell ฉันไม่ต้องการเริ่มสงคราม "Haskell vs Lisp" ที่นี่; สิ่งที่ฉันต้องการรู้คือ: ถ้าฉันเรียนรู้ Haskell เป็นหลักสำหรับการเปิดรับฟังก์ชั่นการเขียนโปรแกรมฉันจะได้ประโยชน์อะไรจากการเรียนรู้ Lisp ในภายหลัง

40 learning  functional-programming  haskell  lisp  paradigms 

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

39 functional-programming  haskell 

ส่วนที่ 1 ชัดเจนไม่สามารถตัดทอนความต้องการล็อคในการเขียนโปรแกรมแบบมัลติโปรเซสเซอร์ลดความต้องการนั้นหรือมีกรณีที่ความไม่สามารถเปลี่ยนได้เพียงอย่างเดียวไม่เพียงพอหรือไม่? สำหรับฉันดูเหมือนว่าคุณสามารถเลื่อนการประมวลผลและรัฐแค็ปซูลได้นานก่อนที่โปรแกรมส่วนใหญ่จะต้องทำอะไรบางอย่างจริง (อัปเดตแหล่งข้อมูลสร้างรายงานยกเว้นข้อยกเว้น ฯลฯ ) การกระทำดังกล่าวสามารถทำได้โดยไม่ล็อคหรือไม่? การกระทำเพียงแค่โยนวัตถุแต่ละชิ้นออกไปและสร้างใหม่แทนที่จะเปลี่ยนแบบเดิม (มุมมองที่หยาบคายของการเปลี่ยนแปลงไม่ได้) ให้การป้องกันที่สมบูรณ์จากการโต้แย้งระหว่างกระบวนการหรือมีมุมที่ยังต้องล็อค? ฉันรู้ว่าโปรแกรมเมอร์และนักคณิตศาสตร์ที่ใช้งานได้จำนวนมากชอบพูดถึง "ไม่มีผลข้างเคียง" แต่ใน "โลกแห่งความจริง" ทุกอย่างมีผลข้างเคียงแม้ว่าจะถึงเวลาที่ต้องใช้คำสั่งเครื่อง ฉันสนใจทั้งคำตอบเชิงทฤษฎี / วิชาการและคำตอบเชิงปฏิบัติ / โลกแห่งความจริง หากความไม่สามารถเปลี่ยนแปลงได้ปลอดภัยตามขอบเขตหรือสมมติฐานบางอย่างฉันต้องการทราบว่าขอบเขตของ "เขตปลอดภัย" คืออะไรกันแน่ ตัวอย่างของขอบเขตที่เป็นไปได้: I / O ยกเว้น / ข้อผิดพลาด การโต้ตอบกับโปรแกรมที่เขียนเป็นภาษาอื่น การโต้ตอบกับเครื่องอื่น ๆ (ทางกายภาพเสมือนหรือตามทฤษฎี) ขอขอบคุณเป็นพิเศษสำหรับ @JimmaHoffa สำหรับความคิดเห็นของเขาซึ่งเริ่มต้นคำถามนี้! ส่วนที่ 2 การเขียนโปรแกรมหลายตัวประมวลผลมักจะใช้เป็นเทคนิคการเพิ่มประสิทธิภาพ - เพื่อให้โค้ดทำงานได้เร็วขึ้น เมื่อไหร่ที่จะใช้การล็อคกับวัตถุที่ไม่เปลี่ยนรูปได้เร็วขึ้น? เมื่อพิจารณาถึงขีด จำกัด ที่กำหนดไว้ในกฎหมายของ Amdahlคุณสามารถบรรลุประสิทธิภาพที่เหนือกว่าทุกประการ (ไม่ว่าจะมีหรือไม่มีตัวเก็บขยะที่พิจารณา) กับวัตถุที่ไม่เปลี่ยนรูปหรือการล็อควัตถุที่ไม่แน่นอน …

39 functional-programming  multithreading  synchronization  immutability  locks 

ฉันได้เห็นว่าในกระบวนทัศน์ที่จำเป็น f (x) + f (x) อาจไม่เหมือนกับ: 2 * f (x) แต่ในกระบวนทัศน์การทำงานมันควรจะเหมือนกัน ฉันได้ลองใช้ทั้งสองกรณีใน Python และSchemeแต่สำหรับฉันแล้วพวกเขาดูตรงไปตรงมาเหมือนกัน อะไรคือตัวอย่างที่สามารถชี้ให้เห็นความแตกต่างกับฟังก์ชั่นที่ให้

38 functional-programming  imperative-programming 

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

38 functional-programming