วิศวกรรมซอฟต์แวร์

ฉันใช้ห้องสมุดภายในที่ถูกออกแบบมาเพื่อเลียนแบบเสนอห้องสมุด C ++และในช่วงไม่กี่ปีที่ผ่านมาผมเห็นอินเตอร์เฟซที่เปลี่ยนจากการใช้เพื่อstd::stringstring_view ดังนั้นฉันจึงเปลี่ยนรหัสตามหน้าที่ให้สอดคล้องกับอินเทอร์เฟซใหม่ น่าเสียดายที่สิ่งที่ฉันต้องผ่านคือพารามิเตอร์ std :: string และสิ่งที่เป็นค่าส่งคืน std :: string ดังนั้นรหัสของฉันเปลี่ยนจากสิ่งนี้: void one_time_setup(const std::string & p1, int p2) { api_class api; api.setup (p1, special_number_to_string(p2)); } ถึง void one_time_setup(const std::string & p1, int p2) { api_class api; const std::string p2_storage(special_number_to_string(p2)); api.setup (string_view(&p1[0], p1.size()), string_view(&p2_storage[0], p2_storage.size())); } ฉันจริงๆไม่เห็นสิ่งที่เปลี่ยนแปลงนี้ซื้อฉันเป็นลูกค้าของ API นอกเหนือจากรหัสอื่น …

16 c++  api-design  strings 

สำหรับคนไอทีจำนวนมากรวมถึงตัวผมเองเมื่อไม่กี่ปีที่ผ่านมากระบวนการพัฒนาซอฟต์แวร์ที่เหมาะสมจะเกี่ยวข้องกับการสร้างเอกสารการออกแบบอย่างละเอียดพร้อมไดอะแกรม UML จำนวนมากก่อนที่จะมีการเขียนบรรทัดโค้ด (ดูเหมือนว่าคำอธิบายของโมเดลน้ำตก แต่จะเหมือนกันกับว่องไวยกเว้นว่าการทำซ้ำจะเล็กกว่า) ในช่วงสองหรือสามปีที่ผ่านมาฉันเปลี่ยนใจโดยสิ้นเชิง ฉันยังคิดว่าข้อกำหนดรายละเอียดความต้องการพร้อมกรณีทดสอบที่เกี่ยวข้องนั้นเป็นสิ่งจำเป็นอย่างยิ่ง สำหรับโครงการขนาดใหญ่ฉันก็ต้องการโครงร่างของสถาปัตยกรรมโดยรวมก่อนที่จะเริ่มโค้ด แต่ส่วนที่เหลือทั้งหมดควรทำในรหัสมากที่สุด ในกรณีที่เหมาะสมไม่ควรมีคำอธิบายของการออกแบบซอฟต์แวร์ยกเว้นรหัสเอง ฉันมาถึงข้อสรุปนี้ได้อย่างไร นี่คือข้อโต้แย้งบางอย่าง: ผลตอบรับ เครื่องมือสำหรับการเขียนเอกสารหรือสร้างไดอะแกรมนั้นให้ผลป้อนกลับเล็กน้อย ใช่มีเครื่องมือสร้างแบบจำลองที่ทำการตรวจสอบความสอดคล้องบนไดอะแกรม UML แต่มีข้อ จำกัด และมาพร้อมกับค่าใช้จ่ายจำนวนมาก หากไม่มีข้อเสนอแนะมันเป็นการยากที่จะรับรู้และแก้ไขข้อผิดพลาด ทันทีที่คุณเขียนรหัสคุณจะได้รับข้อเสนอแนะมากมายเช่น: ข้อผิดพลาดและคำเตือนจากคอมไพเลอร์ ผลการวิเคราะห์รหัสคงที่ การทดสอบหน่วย สามารถจดจำและแก้ไขข้อผิดพลาดได้อย่างรวดเร็ว ความมั่นคง เพื่อให้แน่ใจว่ารหัสสอดคล้องกับเอกสารของคุณคุณต้องตรวจสอบอีกครั้งและอีกครั้ง หากมีการเปลี่ยนแปลงบ่อยครั้งจะเป็นการยากที่จะทำให้รหัสและเอกสารตรงกัน refactoring มีเครื่องมือและเทคนิคที่มีประสิทธิภาพสำหรับการ refactoring code ในขณะที่การ refactoring textual description หรือไดอะแกรมมักจะยากและเกิดข้อผิดพลาดได้ง่าย มีเงื่อนไขหนึ่งที่จะทำให้งานนี้: รหัสจะต้องง่ายพอที่จะอ่านและทำความเข้าใจ สิ่งนี้อาจไม่สามารถทำได้ด้วย Assembler, Basic หรือ Fortran แต่ภาษาสมัยใหม่ (และห้องสมุด) มีความหมายมากกว่า ดังนั้นหากข้อโต้แย้งของฉันถูกต้องควรมีแนวโน้มไปสู่ข้อกำหนดและเอกสารการออกแบบซอฟต์แวร์ที่มีน้ำหนักเบาหรือน้อย มีหลักฐานเชิงประจักษ์สำหรับแนวโน้มนี้หรือไม่?

16 design  programming-languages  development-process  modeling 

ก่อนอื่นขอโทษสำหรับชื่อฉันไม่สามารถคิดถึงวิธีที่ง่ายที่สุดในการอธิบาย! ฉันมีวิธีที่ฉันต้องการเขียนการทดสอบหน่วยสำหรับ ฉันจะให้มันค่อนข้างทั่วไปเพราะฉันไม่ต้องการพูดคุยเกี่ยวกับการใช้งานของวิธีการเพียงแค่การทดสอบของมัน วิธีการคือ: public void HandleItem(item a) { CreateNewItem(); UpdateStatusOnPreviousItem(); SetNextRunDate(); } ดังนั้นคลาสนี้มีวิธีพับลิกหนึ่งที่เรียกใช้เมธอดส่วนตัวเพื่อทำตรรกะ ดังนั้นเมื่อเขียนการทดสอบหน่วยฉันต้องการตรวจสอบทั้งสามสิ่งได้ทำไปแล้ว ในขณะที่พวกเขาทั้งหมดถูกเรียกใช้ในการทำงานเดียวกันฉันคิดว่าฉันสามารถทำได้เป็นแบบทดสอบเดียว: public void GivenItem_WhenRun_Thenxxxxx { HandleItem(item); // Assert item has been created // Assert status has been set on the previous item // Assert run date has been set } แต่ฉันคิดว่าฉันสามารถเขียนเป็นแบบทดสอบแยกกันสามแบบ: public void GivenItem_WhenRun_ThenItemIsCreated() { …

16 c#  unit-testing 

ตรรกะจริงเท่านั้นอยู่ในไวยากรณ์แบบสอบถามสำหรับ API ภายนอก ฉันไม่ต้องการทดสอบว่าจะสอบถาม api หรือไม่ฉันต้องการทดสอบว่าจะทำการสอบถามด้วยวิธีการที่จะส่งคืนข้อมูลที่ถูกต้องหรือไม่ ตัวอย่างเช่นบางรหัสหลอก: function retrieve_related_data(id) { query = "[potentially long, syntactically complex query that uses param id to get some data]"; results = api_wrapper.query(query); return results; } ตัวอย่างที่เป็นรูปธรรมมากขึ้นด้วย API ที่สร้างขึ้น: function retrieveLifeSupportingObjectsWithinRegion(id) { query = " within region(" + id + ") as r find objects …

16 unit-testing  testing  integration-tests 

ฉันเริ่มงานเป็นโปรแกรมเมอร์รุ่นพี่เมื่อไม่กี่เดือนที่ผ่านมา ระบบที่เรากำลังดำเนินการอยู่ได้รับการผลิตเป็นเวลา ~ 2 ปี ฉันไม่ได้เกี่ยวข้องกับการขอร้องของระบบและการออกแบบ สิ่งหนึ่งที่ฉันสังเกตเห็นได้คือรุ่นหลักของระบบนั้นมีอยู่แล้ว 11.YZ จากประสบการณ์ของฉันที่ทำงานกับระบบและไลบรารีอื่น ๆ ฉันไม่จำการเห็นผลิตภัณฑ์เวอร์ชันหลักกระแทกอย่างรวดเร็ว มีผลิตภัณฑ์ที่มีมานานหลายปีใน 1.XY และยังคงได้รับคุณสมบัติและแก้ไขข้อบกพร่อง สมมติว่าการใช้เวอร์ชันเชิงความหมายถูกต้องหรือไม่นี่บ่งชี้ว่าระบบได้รับการออกแบบไม่ดีเนื่องจากทำให้เกิดการเปลี่ยนแปลงครั้งใหญ่เกือบทุกสี่เดือนหรือไม่

16 versioning  semantic-versioning 

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

16 design  go 

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

16 unit-testing  third-party-libraries  wrapper 

ฉันได้พัฒนาซอฟต์แวร์ในช่วงสามปีที่ผ่านมา แต่ฉันเพิ่งตื่นขึ้นมาเมื่อไม่นานมานี้ว่าฉันเป็นคนที่มีแนวปฏิบัติที่ดี สิ่งนี้ทำให้ฉันเริ่มอ่านClean Codeของหนังสือซึ่งทำให้ชีวิตของฉันกลับมาดีขึ้น แต่ฉันพยายามดิ้นรนเพื่อให้เข้าใจถึงวิธีการที่ดีที่สุดในการเขียนโปรแกรมของฉัน ฉันมีโปรแกรม Python ที่ฉัน ... ใช้ argparse required=Trueเพื่อบังคับใช้สองอาร์กิวเมนต์ซึ่งเป็นทั้งชื่อไฟล์ ตัวแรกคือชื่อไฟล์อินพุตส่วนที่สองคือชื่อไฟล์เอาต์พุต มีฟังก์ชั่นreadFromInputFileที่ตรวจสอบก่อนเพื่อดูว่าชื่อไฟล์อินพุตถูกป้อน มีฟังก์ชั่นwriteToOutputFileที่ตรวจสอบก่อนเพื่อดูว่ามีการป้อนชื่อไฟล์เอาต์พุต โปรแกรมของฉันมีขนาดเล็กพอที่จะทำให้ฉันเชื่อว่าการตรวจสอบใน # 2 และ # 3 ซ้ำซ้อนและควรถูกลบออกจึงทำให้ทั้งสองฟังก์ชั่นพ้นจากifสภาพที่ไม่จำเป็น อย่างไรก็ตามฉันก็ถูกชักนำให้เชื่อว่า "การตรวจสอบซ้ำสองครั้งก็โอเค" และอาจเป็นคำตอบที่ถูกต้องในโปรแกรมที่สามารถเรียกใช้ฟังก์ชันได้จากตำแหน่งอื่นที่การแยกวิเคราะห์ของอาร์กิวเมนต์ไม่เกิดขึ้น (นอกจากนี้หากการอ่านหรือเขียนล้มเหลวฉันมีtry exceptในแต่ละฟังก์ชั่นเพื่อเพิ่มข้อความแสดงข้อผิดพลาดที่เหมาะสม) คำถามของฉันคือดีที่สุดที่จะหลีกเลี่ยงการตรวจสอบสภาพซ้ำซ้อนทั้งหมดหรือไม่ ควรตรรกะของโปรแกรมเป็นของแข็งที่ตรวจสอบต้องทำเพียงครั้งเดียว? มีตัวอย่างที่ดีที่แสดงถึงสิ่งนี้หรือการสนทนาหรือไม่? แก้ไข: ขอบคุณทุกคำตอบ! ฉันได้เรียนรู้บางอย่างจากแต่ละคน การได้เห็นมุมมองมากมายทำให้ฉันมีความเข้าใจที่ดีขึ้นเกี่ยวกับวิธีแก้ไขปัญหานี้และกำหนดวิธีการแก้ปัญหาตามความต้องการของฉัน ขอขอบคุณ!

16 clean-code  methodology 

ความเข้าใจของฉันจากการอ่านหัวข้อเช่นนี้คือจุดของ EMS คือการกำหนดการวัดทั้งหมดในหน้าเว็บของคุณด้วยขนาดตัวอักษรพื้นฐานซึ่งสามารถตั้งค่าได้โดยเบราว์เซอร์ของคุณ ยกตัวอย่างเช่นใน Chrome settings -> show advanced settings -> web content -> font size: very largeที่คุณสามารถทำเช่นนี้ได้โดยไป ฉันอาจทำสิ่งนี้ถ้าฉันใช้จอมอนิเตอร์ความละเอียดสูงขนาดใหญ่ที่อยู่ไกล ฉันสร้างพลั่วเกอร์ที่แสดงความแตกต่างระหว่าง ems และ px ในการปรับขนาด #div1 { width: 320px } #div2 { width: 20em; } หากในเบราว์เซอร์ของฉันฉันตั้งขนาดตัวอักษรเป็นขนาดกลาง div เหล่านี้จะมีขนาดเท่ากันขนาดตัวอักษรพื้นฐานคือ 16px ดังนั้น 20em = 320px อย่างไรก็ตามเมื่อฉันเปลี่ยนขนาดแบบอักษรของเบราว์เซอร์เป็นใหญ่มากเราจะเห็นว่า div ที่วัดเป็น EMS นั้นมีขนาดเพิ่มขึ้น อย่างไรก็ตามเอฟเฟกต์นี้จะถูกลบหากฉันกำหนดขนาดตัวอักษรในแท็ก body เช่น …

16 css 

คำถามนี้จะคล้ายกับคนนี้แต่คำตอบไม่ตรงกับความต้องการของฉัน มันมุ่งเน้นไปที่เครื่องมือ UML เฉพาะ (Papyrus) ในขณะที่คำถามของฉันเป็นเรื่องทั่วไปเกี่ยวกับ UML ฉันต้องการที่จะเป็นตัวแทนของการกระทำที่ซ้อนกันในแผนภาพกิจกรรมแต่ฉันไม่ทราบว่าวิธีการทำมันคืออะไร แนวคิดคือมีการกระทำในขอบเขตเดียวกันมากกว่าการกระทำอื่น แต่มีความซับซ้อนในการดำเนินการ ฉันต้องการแสดงรายละเอียดเพิ่มเติมเกี่ยวกับการดำเนินการของมันในขณะที่ยังสามารถแสดงการกระทำนี้ในระดับเดียวกันกว่าที่อื่น ๆ ในตัวอย่างด้านล่างซึ่งเป็นแผนภาพกิจกรรมที่แสดงกิจกรรม " กลับบ้าน " บางอย่างการกระทำที่ซ้อนกันอยู่ในการPet the catดำเนินการ โปรดทราบว่ามีข้อผิดพลาดที่อาจเกิดขึ้นอีกในแผนภาพนี้ดูข้อผิดพลาดในตอนท้ายของคำถาม ฉันได้ใช้โหนดที่มีโครงสร้าง แต่ฉันไม่แน่ใจว่ามันเป็นวิธีที่ถูกต้องดังนั้นคำถาม ในสถานะชาร์ตเทียบเท่าจะเป็นคอมโพสิต แต่ฉันก็ไม่สามารถหาอะไรเกี่ยวกับคอมโพสิตแอ็คชั่น เกี่ยวกับโหนดที่มีโครงสร้างหลังจากอ่านเอกสารสองสามฉบับเกี่ยวกับมันฉันยังไม่เข้าใจว่ามันควรจะใช้อย่างไรดังนั้นฉันอาจผิดทั้งหมดกับแผนภาพนี้ ฉันรู้ด้วยว่ามีความเป็นไปได้ที่จะอ้างถึงกิจกรรมย่อยอื่นที่มีสัญลักษณ์ตรีศูลตามภาพด้านล่าง แต่มันไม่ตรงกับความต้องการของฉันเพราะฉันต้องการข้อมูลทั้งหมดในแผนภาพเดียวกัน (ดังนั้นฉันจึงสามารถพิมพ์ได้ มันโดยไม่สูญเสียข้อมูลใด ๆ ): ดังนั้นวิธีมาตรฐานในการเป็นตัวแทนของการกระทำที่ซ้อนกันคืออะไร? ตามมาตรฐานฉันหมายถึง UML ที่ถูกต้องที่เห็นได้ทั่วไปและหากเป็นไปได้สามารถทำได้ในเครื่องมือออกแบบ UML ส่วนใหญ่ errata ที่ไม่เกี่ยวข้อง: มีอีกอย่างหนึ่งที่ผิดในแผนภาพของฉันลูกศรที่เข้ามาสู่การกระทำแบบเดียวกัน ( Scratch behind the ears) ควรไปที่โหนดที่รวมกันก่อนที่จะเข้าสู่การกระทำ ดูความคิดเห็นด้านล่างรวมทั้งคำพูดของ JOT

16 uml  modeling 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้นี้ ปิดให้บริการใน3 ปีที่ผ่านมา ดังนั้นฉันจึงกำลังทำงานในโครงการใหม่พร้อมกับหัวหน้าโครงการของฉันในช่วง 1 ปีที่ผ่านมา ตอนแรกเรามีโปรเจคย่อยของเราที่อาศัยอยู่ใน repos git แยกกันฉันมีปฏิสัมพันธ์กับโค้ดของเขาน้อยดังนั้นกลิ่นโค้ดไม่ได้รบกวนฉัน ประมาณ 6 เดือนต่อมาฉันเริ่มรักษาและเพิ่มฟีเจอร์ในโค้ดของเขาเนื่องจากฉันมีบทบาทมากขึ้นในโครงการ ตอนนี้ฉันเป็นผู้พัฒนานำสำหรับทั้งโครงการย่อย (ทีมกำลังจะเติบโต; เขายังอยู่เหนือฉัน) สิ่งเหล่านี้รบกวนฉันและฉันต้องการดูแลพวกเขา แต่ถูกปฏิเสธ: ไม่มีเครื่องหมายปีกกา, ฟังก์ชันตัวพิมพ์ใหญ่, การใช้คำพูดแบบผสม (ตรรกะดับเบิลและเดี่ยวที่มีลอจิกซ่อน), ไม่ใช้ ===, คลาสเรียนขนาดใหญ่พร้อมฟังก์ชั่นมากมาย บรรทัดล่างอาจจะดีกว่า พึ่งพาตัวเลือกของ PHP เพื่อปิดการแจ้งเตือน / คำเตือน รหัสเต็มไปด้วยการใช้ตัวแปรและคีย์อาร์เรย์ ตัวแปรถูกนิยามไว้ภายใน ifs ข้อโต้แย้งเกี่ยวกับปัญหา 2 ข้อข้างต้น: ไม่ต้องการบังคับใช้รูปแบบการเข้ารหัสกับผู้คน ถือได้ว่าเป็นคุณสมบัติภาษาซึ่งยืมตัวเองเพื่อรหัสสั้น / มีประสิทธิภาพมากขึ้น ฉันเชื่อว่ากฎบางอย่างจำเป็นต้องมีและรหัสควรมีการป้องกัน ฉันเสนอให้ใช้การตั้งค่าเริ่มต้นของ PHPS สำหรับการจัดรูปแบบใช้เครื่องหมายปีกกาและการตั้งชื่อที่ชุมชนยอมรับ ฉันต้องการจัดแนวทั้งสองโครงการให้ใช้แนวทางเดียวกันเนื่องจากแยกกันไม่ออก …

16 php  coding-standards  team 

ฉันทำงานกับ javascript ตลอด 4 ปีที่ผ่านมา ฉันมีความมั่นใจมากเกี่ยวกับทักษะการแก้ปัญหาของฉันและฉันเห็นได้ว่าคุณภาพรหัสของฉันดีขึ้น ฉันพยายามติดตามชุมชนและฉันกำลังทำงานกับ ES2015 และ React.js อย่างไรก็ตามฉันรู้สึกว่าฉันไม่สามารถเข้าใจรูปแบบการออกแบบโปรแกรมได้เลย ฉันรู้ว่าจะหาแหล่งข้อมูลเกี่ยวกับเรื่องนี้ได้ที่ไหนและฉันได้อ่านหนังสือเกี่ยวกับเรื่องนี้แล้ว ฉันพึ่งพาเพื่อนร่วมงานอาวุโสของฉันในการตัดสินใจเกี่ยวกับโครงสร้างโครงการ แต่ฉันไม่มีปัญหาในการทำงาน เมื่อใดก็ตามที่ฉันต้องการเริ่มต้นด้วยตัวเองฉันจะมองหาสองเส้นทางนี้: ถ้าฉันใช้ห้องสมุด / กรอบใหญ่อย่าง React.js ฉันมักจะคัดลอกสิ่งที่ชุมชนกำลังทำอยู่ ถ้าฉันทำอะไรที่เล็กลงฉันจะใช้รูปแบบโมดูล ฉันรู้ว่าเมื่อฉันได้รับความเข้าใจที่ดีขึ้นในเรื่องนี้ฉันจะสามารถตัดสินใจได้ดีขึ้น แต่ตอนนี้ฉันหลงทางไปแล้ว ฉันควรมองหาการศึกษาขั้นสูงในเรื่องนี้หรือไม่? ฉันต้องการที่ปรึกษาในเรื่องนี้หรือไม่? ฉันแค่โง่เหรอ? นี่มันยากที่จะเข้าใจใช่ไหม

16 design-patterns  javascript 

แนวคิดนี้ได้รับแรงบันดาลใจจากตัวดำเนินการข้อเท็จจริงเช่น +, -,%, เป็นต้นซึ่งสามารถมองเห็นได้ว่าเป็นฟังก์ชั่นที่ผ่านการโต้แย้งหนึ่งหรือสองครั้งและไม่มีผลข้างเคียง สมมติว่าฉันหรือคนอื่นเขียนภาษาที่หยุดไม่ให้มีการโต้แย้งมากกว่าสองข้อและยังใช้งานได้ผ่านการส่งคืนเท่านั้น: ก) ภาษานั้นจะทำให้เข้าใจรหัสได้ง่ายขึ้นหรือไม่ b) การไหลของรหัสจะชัดเจนขึ้นหรือไม่ (บังคับให้ทำตามขั้นตอนมากขึ้นโดยที่การโต้ตอบ 'ซ่อน' อาจมีน้อยลง c) ข้อ จำกัด จะทำให้ภาษามีขนาดใหญ่เกินไปสำหรับโปรแกรมที่ซับซ้อนมากขึ้น d) (โบนัส) ความคิดเห็นอื่น ๆ เกี่ยวกับข้อดี / ข้อเสีย บันทึก: การตัดสินใจสองครั้งจะยังคงต้องทำก่อนคืออนุญาตให้ผู้ใช้ป้อนข้อมูลนอกหลัก () หรือเทียบเท่าและสิ่งที่กฎจะเกี่ยวกับสิ่งที่เกิดขึ้นเมื่อผ่านอาร์เรย์ / โครงสร้าง ตัวอย่างเช่นหากมีคนต้องการฟังก์ชั่นเดียวที่จะเพิ่มค่าหลายค่าเขาสามารถหลีกเลี่ยงข้อ จำกัด โดยรวมมันเข้าไปในอาร์เรย์ สิ่งนี้สามารถหยุดได้โดยไม่อนุญาตให้อาร์เรย์หรือโครงสร้างจากการโต้ตอบกับตัวเองซึ่งจะช่วยให้คุณตัวอย่างเช่นหารจำนวนแต่ละจำนวนด้วยจำนวนที่แตกต่างกันขึ้นอยู่กับตำแหน่งของมัน

16 design  programming-languages  functional-programming  functions 

isocpp.org ข้อยกเว้น FAQระบุสถานะ อย่าใช้ Throw เพื่อระบุข้อผิดพลาดในการใช้งานฟังก์ชั่น ใช้ assert หรือกลไกอื่น ๆ เพื่อส่งกระบวนการไปยังดีบักเกอร์หรือเพื่อทำให้กระบวนการทำงานผิดพลาดและเก็บรวบรวมดัมพ์ของข้อผิดพลาดเพื่อให้นักพัฒนาทำการดีบัก ในทางกลับกันไลบรารีมาตรฐานจะกำหนด std :: logic_error และทั้งหมดเป็นอนุพันธ์ซึ่งดูเหมือนว่าฉันควรจะจัดการนอกเหนือจากสิ่งอื่น ๆ ข้อผิดพลาดในการเขียนโปรแกรม กำลังส่งสตริงว่างไปยัง std :: stof (จะโยน invalid_argument) ไม่ใช่ข้อผิดพลาดในการเขียนโปรแกรมหรือไม่? การส่งสตริงที่มีอักขระที่แตกต่างจาก '1' / '0' ถึง std :: bitset (จะส่ง invalid__chument) ไม่ใช่ข้อผิดพลาดในการเขียนโปรแกรมหรือไม่? กำลังเรียก std :: bitset :: set ด้วยดัชนีที่ไม่ถูกต้อง (จะโยน out_of_range) ไม่ใช่ข้อผิดพลาดในการเขียนโปรแกรมหรือไม่? หากสิ่งเหล่านี้ไม่ใช่ข้อผิดพลาดในการเขียนโปรแกรมที่จะทดสอบคืออะไร ตัวสร้างสตริงที่ใช้ std :: …

16 design  c++  exceptions 

เมื่อเร็ว ๆ นี้ฉันได้ปัดความรู้ของฉันเกี่ยวกับวิธีการทำงานของ Monads ฉันยังได้รับการแนะนำให้รู้จักกับแนวคิดของการเป็น'Comonad'ซึ่งจะอธิบายเป็นผกผันสองของ monad อย่างไรก็ตามฉันไม่สามารถคาดศีรษะได้ เพื่อทำความเข้าใจ Monads ฉันได้ทำการเปรียบเทียบของตัวเอง: Monads สามารถมองเห็นเป็น 'พิมพ์เขียวเพื่อสร้างสายพานลำเลียงของการแสดงออก' ในการกำหนด Monad ใหม่ (ระบบสายพานแบบใหม่) คุณต้องกำหนด: วิธีวางสิ่งของบนสายพานลำเลียงเช่น 'เริ่ม' สายพาน (รู้จักในชื่อunitหรือreturn) วิธีเชื่อมต่อเครื่อง (นิพจน์) ที่จะเป็นส่วนหนึ่งของสายพานลำเลียงเข้ากับสายพาน (ที่รู้จักกันjoinหรือbindหรือ>>=) (มีการดำเนินการที่สามที่ใช้สายพานลำเลียงในปัจจุบันโยนเนื้อหาออกไปและเริ่มสายพานลำเลียงใหม่ที่รู้จักกันในนาม>>แต่ใช้งานบ่อยครั้งมาก) เพื่อให้เครื่องจักรและสายพานทำงานร่วมกันอย่างเหมาะสมคุณจะต้องตรวจสอบให้แน่ใจว่า: หากคุณใส่อะไรลงบนสายพานลำเลียงและส่งผ่านเครื่องผลลัพธ์ที่ได้ควรจะเหมือนกับเมื่อคุณส่งผ่านเครื่องด้วยตนเอง (ข้อมูลประจำตัวด้านซ้าย) หากคุณต้องการใส่สายพานลำเลียงระหว่างสายพานที่มีอยู่แล้วคุณไม่ควรท้ายด้วยสายพานลำเลียงที่มีสายพานลำเลียงอยู่ด้านบน แต่ควรเป็นสายพานที่ยาวกว่า (เอกลักษณ์ที่ถูกต้อง) มันไม่สำคัญสำหรับผลลัพธ์ถ้าคุณใช้เครื่อง A ด้วยตนเองแล้วส่งผลลัพธ์ผ่าน BC ที่เชื่อมต่อกับเครื่องลำเลียงหรือถ้าคุณใช้ AB ที่เชื่อมต่อกับเครื่องลำเลียงแล้วจากนั้นส่งผลลัพธ์ด้วยตนเองผ่าน C ในคำอื่น ๆ : (( >> = b) >> = …

16 functional-programming  monad