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

ขณะนี้ฉันอยู่ในขั้นตอนการออกแบบ (อีกครั้ง) ของคลาสรุ่นต่างๆของแอปพลิเคชัน C # .NET (โมเดลดังใน M ของ MVC) คลาสโมเดลมีข้อมูลพฤติกรรมและความสัมพันธ์ซึ่งได้รับการออกแบบมาเป็นอย่างดี ฉันเขียนแบบจำลองใหม่จาก Python เป็น C # ใน Python model ฉันคิดว่าฉันเห็นหูด แต่ละรุ่นรู้วิธีการทำให้เป็นอันดับตัวเองและตรรกะการทำให้เป็นอันดับไม่มีส่วนเกี่ยวข้องกับพฤติกรรมที่เหลือของคลาสใด ๆ ตัวอย่างเช่นลองนึกภาพ: Imageชั้นเรียนด้วย.toJPG(String filePath) .fromJPG(String filePath)วิธีการ ImageMetaDataชั้นเรียนด้วย.toString()และ.fromString(String serialized)วิธีการ คุณสามารถจินตนาการได้ว่าวิธีการทำให้เป็นอันดับเหล่านี้ไม่ได้เชื่อมโยงกับส่วนที่เหลือของชั้นเรียน แต่มีเพียงชั้นเรียนเท่านั้นที่สามารถรับประกันได้ว่าจะรู้ข้อมูลที่เพียงพอในการทำให้เป็นอันดับตัวเอง มันเป็นเรื่องธรรมดาสำหรับชั้นเรียนหรือไม่ที่จะรู้วิธีการทำให้เป็นอันดับและทำให้เสียความเป็นตัวของตัวเอง? หรือฉันไม่มีรูปแบบทั่วไป

16 c#  object-oriented  python  serialization 

ฉันต้องเขียน RandomQueue ที่อนุญาตให้ผนวกและลบแบบสุ่มใน Constant Time (O (1)) ความคิดแรกของฉันคือการสำรองข้อมูลด้วย Array บางประเภท (ฉันเลือก ArrayList) เนื่องจากอาร์เรย์มีการเข้าถึงอย่างต่อเนื่องผ่านดัชนี เมื่อมองไปที่เอกสารแม้ว่าฉันรู้ว่าการเพิ่มเติมของ ArrayLists ถือเป็น Amortized Constant Time เนื่องจากการเพิ่มอาจต้องมีการจัดสรรใหม่ของอาเรย์พื้นฐานซึ่งก็คือ O (n) Amortized Constant Time และ Constant Time มีประสิทธิภาพเหมือนกันหรือไม่หรือฉันต้องดูโครงสร้างบางอย่างที่ไม่ต้องการการจัดสรรใหม่อย่างสมบูรณ์ในทุก ๆ การเติม ฉันถามสิ่งนี้เพราะโครงสร้างแบบอาเรย์กัน (ซึ่งเท่าที่ฉันรู้จะมีการเพิ่มค่าคงที่ตลอดเวลา) ฉันไม่สามารถคิดอะไรที่ตรงตามข้อกำหนด: ต้นไม้ใดก็ตามที่มีการเข้าถึง O (log n) จะดีที่สุด รายการที่เชื่อมโยงอาจมีการเพิ่ม O (1) (ถ้าการอ้างอิงไปยังหางถูกเก็บไว้) แต่การลบแบบสุ่มควรจะดีที่สุด O (n) นี่คือคำถามเต็ม ในกรณีที่ฉันเคลือบรายละเอียดที่สำคัญบางอย่าง: ออกแบบและใช้งาน RandomQueue …

16 algorithms  complexity 

ประสิทธิภาพที่รวดเร็วกว่าคืออะไร การสร้าง REST API และการมีเว็บแอปของคุณใช้ REST API เพื่อทำการโต้ตอบกับฐานข้อมูลของคุณหรือทำการสืบค้นฐานข้อมูลของคุณโดยตรง (เช่นการใช้วัตถุทั่วไปที่ภาษาของคุณใช้ในการสืบค้นฐานข้อมูลเช่น JDBC for Java)? วิธีที่ฉันเห็นด้วย REST: คุณสร้างวัตถุในรหัสของคุณเพื่อเรียกใช้วิธีการ REST โทรวิธี http รหัสภายใน REST API ของคุณจะค้นหาฐานข้อมูล ฐานข้อมูลส่งคืนข้อมูลบางส่วน รหัส REST API จะแพ็คข้อมูลลงใน Json และส่งไปยังลูกค้าของคุณ ลูกค้าได้รับการตอบสนอง Json / XML แมปการตอบสนองกับวัตถุในรหัสของคุณ ในทางตรงกันข้ามการสืบค้นฐานข้อมูลโดยตรง: คุณทำวัตถุด้วยสายอักขระแบบสอบถามเพื่อสอบถามฐานข้อมูล ฐานข้อมูลส่งคืนข้อมูลบางส่วน แมปการตอบสนองกับวัตถุในรหัสของคุณ ดังนั้นนี่ไม่ได้หมายความว่าการใช้ REST API จะช้าลงหรือไม่ อาจขึ้นอยู่กับประเภทของฐานข้อมูล (SQL กับ NoSQL)?

16 database  rest  sql 

บางคนบอกว่าถ้าคุณนำหลักการของ SOLID มาใช้กับสุดขั้วคุณก็จะจบลงด้วยการเขียนโปรแกรมที่ใช้งานได้ ฉันเห็นด้วยกับบทความนี้ แต่ฉันคิดว่าซีแมนทิกส์บางอย่างหายไปจากการเปลี่ยนจากส่วนต่อประสาน / วัตถุไปเป็นฟังก์ชัน / ปิดและฉันต้องการทราบว่า Function Programming สามารถลดความสูญเสียได้อย่างไร จากบทความ: นอกจากนี้หากคุณใช้หลักการแยกส่วนต่อประสาน (ISP) อย่างจริงจังคุณจะเข้าใจว่าคุณควรใช้การเชื่อมต่อแบบสวมบทบาทแทนการเชื่อมต่อส่วนหัว หากคุณผลักดันการออกแบบของคุณไปสู่อินเทอร์เฟซที่เล็กลงเรื่อย ๆ ในที่สุดคุณจะมาถึงสุดยอด Role Interface: อินเทอร์เฟซด้วยวิธีการเดียว เรื่องนี้เกิดขึ้นกับฉันมาก นี่คือตัวอย่าง: public interface IMessageQuery { string Read(int id); } ถ้าฉันใช้การพึ่งพาIMessageQueryส่วนหนึ่งของสัญญาโดยนัยคือการโทรRead(id)จะค้นหาและส่งคืนข้อความด้วย ID ที่กำหนด เปรียบเทียบสิ่งนี้กับการพึ่งพาของลายเซ็นการทำงานที่เทียบเท่า, int -> string. โดยไม่ต้องชี้นำใด ๆ ToString()เพิ่มเติมฟังก์ชั่นนี้อาจจะง่าย หากคุณดำเนินการIMessageQuery.Read(int id)ด้วยToString()ฉันอาจกล่าวหาว่าคุณถูกโค่นล้มโดยเจตนา! ดังนั้นโปรแกรมเมอร์ฟังก์ชันสามารถทำอะไรได้เพื่อรักษาซีแมนทิกส์ของอินเตอร์เฟสที่มีชื่อดี ยกตัวอย่างเช่นมันเป็นเรื่องธรรมดาที่จะสร้างประเภทเรคคอร์ดโดยมีสมาชิกคนเดียวหรือไม่? type MessageQuery = { …

16 object-oriented  functional-programming  solid 

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

16 licensing  gpl 

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

16 version-control  database-design 

ฉันทำงานกับทีมเล็ก ๆ กับนักพัฒนาระยะไกลอื่น ๆ ในRailsแอปพลิเคชัน เรากำลังเริ่มแก้ไขgitเวิร์กโฟลว์ของเรา เราคิดเกี่ยวกับโครงสร้างการแตกแขนงดังนี้: (dev) -> (qa) -> (stag) -> (master) แต่นักพัฒนาบางคนคิดว่ามันอาจสับสนน้อยกว่าสำหรับนักพัฒนาใหม่ที่อาจผลักดันการผลิตโดยอัตโนมัติ พวกเขาคิดว่าจะให้ทุกคนทำงานเป็นผู้เชี่ยวชาญและสร้างสาขาแยกต่างหากสำหรับการผลิต (master) -> (qa) -> (stag) -> (prod) ฉันได้รับการสอนว่าคุณต้องการให้ต้นแบบสามารถใช้งานได้และไม่ได้ใช้เพื่อการพัฒนาและจากที่ก่อนหน้านี้ที่ฉันเคยทำงานเป็นอาจารย์มักจะนำไปใช้ในการผลิตได้เสมอ อะไรคือข้อเสียของการใช้โครงสร้างการแยกสาขาที่ใช้สำหรับการพัฒนาเป็นหลักและแยกสาขาที่แยกต่างหากคือสิ่งที่คุณใช้สำหรับการปรับใช้?

16 git 

ฉันถามคำถามนี้เพราะฉันสับสนในแง่มุมหนึ่งเกี่ยวกับสัญกรณ์ O ใหญ่ ฉันใช้หนังสือโครงสร้างข้อมูลและบทคัดย่อกับ Javaโดย Frank Carrano ในบทเกี่ยวกับ "ประสิทธิภาพของอัลกอริทึม" เขาแสดงอัลกอริทึมต่อไปนี้: int sum = 0, i = 1, j = 1 for (i = 1 to n) { for (j = 1 to i) sum = sum + 1 } สมัยก่อนเขาอธิบายขั้นตอนวิธีนี้มีอัตราการเติบโต(n 2 + n) / 2 ซึ่งดูง่าย อย่างไรก็ตามมีการระบุไว้ว่า(n 2 + n) …

16 algorithms  big-o 

ฉันค่อนข้างมั่นใจว่าทุกคนคุ้นเคยกับวิธีการทั่วไปของแบบฟอร์ม: T DoSomething<T>(T item) ฟังก์ชั่นนี้เรียกว่า parametrically polymorphic (PP) โดยเฉพาะอันดับ 1 PP สมมติว่าวิธีนี้สามารถแสดงโดยใช้ฟังก์ชั่นวัตถุของรูปแบบ: <T> : T -> T นั่นคือ<T>หมายความว่าใช้พารามิเตอร์ประเภทเดียวและT -> Tหมายความว่าใช้พารามิเตอร์ประเภทเดียวTและส่งกลับค่าประเภทเดียวกัน ต่อไปนี้จะเป็นฟังก์ชัน PP อันดับ 2: (<T> : T -> T) -> int ฟังก์ชั่นไม่มีพารามิเตอร์ประเภทตัวเอง แต่ใช้ฟังก์ชั่นซึ่งใช้พารามิเตอร์ประเภท คุณสามารถทำสิ่งนี้ซ้ำ ๆ ได้โดยทำรังให้ลึกและลึกขึ้นรับ PP ในระดับที่สูงกว่าและสูงกว่า คุณลักษณะนี้หายากมากในบรรดาภาษาการเขียนโปรแกรม แม้แต่ Haskell ก็ไม่อนุญาตตามค่าเริ่มต้น มันมีประโยชน์หรือไม่ มันสามารถอธิบายพฤติกรรมที่ยากที่จะอธิบายเป็นอย่างอื่นได้หรือไม่? นอกจากนี้มันหมายความว่าอะไรที่จะต้องมีความคิดมาก ? (ในบริบทนี้)

16 programming-languages  functional-programming  type-systems  generics 

ฉันมีข้อมูลดิบที่ฉันต้องทำหลายสิ่งเพื่อ (เลื่อนหมุนปรับขนาดตามแกนบางหมุนไปยังตำแหน่งสุดท้าย) และฉันไม่แน่ใจว่าวิธีที่ดีที่สุดในการอ่านโค้ด ในอีกด้านหนึ่งฉันสามารถทำวิธีเดียวที่มีพารามิเตอร์จำนวนมาก (10+) เพื่อทำสิ่งที่ฉันต้องการ แต่นี่เป็นโค้ดที่อ่านฝันร้าย ในทางตรงกันข้ามฉันสามารถสร้างหลายวิธีด้วยพารามิเตอร์ 1-3 ตัว แต่วิธีเหล่านี้จะต้องเรียกตามลำดับที่เฉพาะเจาะจงมากเพื่อให้ได้ผลลัพธ์ที่ถูกต้อง ฉันได้อ่านว่าวิธีที่ดีที่สุดในการทำสิ่งหนึ่งและทำได้ดี แต่ดูเหมือนว่ามีวิธีการมากมายที่ต้องถูกเรียกใช้เพื่อเปิดรหัสสำหรับข้อบกพร่องที่หายาก มีกระบวนทัศน์การเขียนโปรแกรมที่ฉันสามารถใช้ที่จะลดข้อบกพร่องและทำให้รหัสอ่านง่ายขึ้นหรือไม่

16 java  readability 

ฉันแน่ใจว่านักพัฒนา iOS ใหม่ทุกคนมีปัญหาดังต่อไปนี้: ตัวควบคุมมุมมองได้รับความแออัดอย่างรวดเร็วด้วยรหัสสำหรับวัตถุประสงค์ที่หลากหลายรับ 500 บรรทัดของรหัสได้อย่างง่ายดาย นี่คือหน้าตาพื้นฐานและหน้าจอทั่วไปสองแบบ: 1) หน้าจอแบบฟอร์ม: 2) หน้าจอควบคุมมุมมองตาราง จนถึงตอนนี้ฉันได้อ่านเกี่ยวกับโซลูชันที่แตกต่างกันสองวิธี: โซลูชั่นแรก: https://bendyworks.com/single-responsibility-principle-ios/ สิ่งนี้ยึดตามการแจ้งเตือนซึ่งแยกตัวควบคุมมุมมองออกจากตัวแบบมุมมอง (ความตั้งใจ) โดยสมบูรณ์และลดรหัสในตัวควบคุมมุมมอง ฉันคิดว่ามันมีข้อเสียของการทำลายโค้ดคล้ายกับโครงสร้างของ Go-To ดูเหมือนว่านี้: โซลูชันที่สองช่วยให้ View Controller เป็นแออัดเหมือนเดิม (การทำงานของปุ่มจะถูกดำเนินการภายใน VC และอื่น ๆ ) แต่ใช้ไลบรารีเช่นTPKeyboardAvoiding , BlocksKit หรือโซลูชันอื่น ๆ ส่วนใหญ่อ้างอิงจากหมวดหมู่ ด้วยวิธีที่สองนี้รหัสจะลดลงอย่างมาก แต่ตัวควบคุมมุมมองยังคงมีความรับผิดชอบจำนวนมาก คุณคิดอย่างไรเกี่ยวกับการแก้ปัญหาเหล่านี้? ไหนดีกว่ากัน มีดีกว่าไหม

16 mvc  ios  objective-c 

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

16 licensing  apache-license 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน5 ปีที่ผ่านมา ฉันคิดว่าการใช้ชื่อไฟล์นั้นค่อนข้างแพร่หลาย บริษัท ของเราก็ใช้มันเช่นกัน แต่ข้อกังวลหลักของฉันคือชื่อเหล่านี้มักจะไม่ถูกบันทึกไว้ที่ใดก็ได้ และความหมายก็กระจายไปตามคำปาก และชื่อนั้นไม่มีส่วนเกี่ยวข้องกับการทำงานของเครื่องมือหรือเอนทิตีที่มีชื่ออยู่ ฉันเห็นรูปแบบที่เครื่องทดสอบภายในตั้งชื่อตามกลุ่มดาวเซิร์ฟเวอร์สาธารณะที่ตั้งชื่อตามเทพเจ้ากรีก และโครงการจะถูกตั้งชื่อตามสถานที่หรือชื่อของดาราภาพยนตร์หรือชื่อตัวละครที่สุ่มเลือก แต่ไม่มีข้อมูลโดยตรงจากชื่อว่าเครื่องเป็น Windows หรือ Linux; เซิร์ฟเวอร์ 32 หรือ 64 บิต หรือโครงการเกี่ยวกับอะไร ฉันมีความรู้สึกไม่ดีเมื่อเห็นข้อความมอบอำนาจของ VCS ว่ามีใครบางคนแยกโครงการ "แกนดัล์ฟ" หรือโครงการ "Callanish" หรือโครงการอะไรก็ตาม ด้วยเหตุผลเดียวกันคุณไม่ได้ตั้งชื่อฟังก์ชั่นและตัวแปรแบบนั้น ฉันเสนอว่าเราควรใช้ชื่อที่มีความหมายมากกว่านี้อย่างน้อยสำหรับหน่วยงานใหม่ แต่ฉันต้องเผชิญกับการต่อต้านที่แข็งแกร่งมาก เห็นได้ชัดว่าทุกคนในองค์กรยกเว้นฉันรักสิ่งที่ตั้งชื่อเช่นนั้น เหตุใดเราจึงใช้ชื่อรหัสที่ไม่อธิบาย อย่าเข้าใจฉันผิดฉันไม่มีปัญหาในการตั้งชื่อรุ่นและเหตุการณ์สำคัญหรือมีชื่อผลิตภัณฑ์ที่ดีสำหรับเหตุผลทางการตลาด แต่ที่อื่น ๆ ฉันอยากเห็นชื่อที่เป็นคำอธิบายมากกว่านี้ แก้ไข: เพื่อให้บริบท: Gandalf เป็นโครงการที่พอร์ตรหัส 64 บิต Callanish เป็นพอร์ตที่เชื่อมต่อกับ Android …

16 naming  organization 

ปิด คำถามนี้จะต้องมีมากขึ้นมุ่งเน้น ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้มุ่งเน้นที่ปัญหาเดียวโดยแก้ไขโพสต์นี้ ปิดให้บริการใน5 ปีที่ผ่านมา ในฐานะที่เป็นทั้งโปรแกรมเมอร์ C และโปรแกรมเมอร์ C # สิ่งหนึ่งที่ฉันไม่ชอบเกี่ยวกับ C # ก็คือฟังก์ชั่นคณิตศาสตร์ verbose เป็นอย่างไร ทุกครั้งที่คุณต้องใช้ฟังก์ชัน Sin, cosine หรือ power คุณจะต้องเพิ่มคลาสสถิตแบบคณิตศาสตร์ล่วงหน้า สิ่งนี้นำไปสู่โค้ดที่ยาวมากเมื่อสมการนั้นง่ายมาก ปัญหาจะยิ่งแย่ลงหากคุณต้องการพิมพ์ข้อมูลชนิด ดังนั้นในความคิดของฉันการอ่านได้รับความเดือดร้อน ตัวอย่างเช่น: double x = -Math.Cos(X) * Math.Sin(Z) + Math.Sin(X) * Math.Sin(Y) * Math.Cos(Z); ตรงข้ามกับเพียงแค่ double x = -cos(X) * sin(Z) + sin(X) * …

16 java  c#  math  readability 

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

16 functional-programming  side-effect