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

ฉันได้ปรับการออกแบบที่ขับเคลื่อนด้วยโดเมนมาประมาณ 8 ปีแล้วและแม้กระทั่งหลังจากทุกปีเหล่านี้ก็ยังมีสิ่งหนึ่งที่ทำให้ฉันเบื่อ นั่นคือการตรวจสอบระเบียนที่ไม่ซ้ำกันในการจัดเก็บข้อมูลกับวัตถุโดเมน ในเดือนกันยายน 2013 Martin Fowler ได้กล่าวถึงหลักการ TellDonnaAskซึ่งหากเป็นไปได้ควรนำไปใช้กับวัตถุโดเมนทั้งหมดซึ่งควรจะส่งคืนข้อความว่าการดำเนินการเป็นไปอย่างไร (ในการออกแบบเชิงวัตถุ การดำเนินการไม่สำเร็จ) โครงการของฉันมักจะแบ่งออกเป็นหลายส่วนโดยที่สองในนั้นเป็นโดเมน (ที่มีกฎเกณฑ์ทางธุรกิจและไม่มีสิ่งอื่นใดโดเมนนั้นยังคงอยู่อย่างไม่รู้ตัว) และบริการ บริการที่ทราบเกี่ยวกับเลเยอร์พื้นที่เก็บข้อมูลที่ใช้กับข้อมูล CRUD เนื่องจากความเป็นเอกลักษณ์ของคุณสมบัติที่เป็นของวัตถุคือกฎของโดเมน / ธุรกิจจึงควรจะยาวไปยังโมดูลของโดเมนดังนั้นกฎจึงตรงตามที่ควรจะเป็น เพื่อให้สามารถตรวจสอบเอกลักษณ์ของระเบียนคุณต้องค้นหาชุดข้อมูลปัจจุบันซึ่งมักจะเป็นฐานข้อมูลเพื่อค้นหาไม่ว่าจะมีระเบียนอื่นที่มีการสมมติว่าNameมีอยู่แล้ว เมื่อพิจารณาว่าเลเยอร์ของโดเมนนั้นไม่รู้มานานแล้วและไม่รู้ว่าจะดึงข้อมูลได้อย่างไร แต่จะทำอย่างไรกับการดำเนินการกับมันพวกมันไม่สามารถสัมผัสที่เก็บข้อมูลได้ การออกแบบที่ฉันได้รับการปรับตัวแล้วมีลักษณะเช่นนี้: class ProductRepository { // throws Repository.RecordNotFoundException public Product GetBySKU(string sku); } class ProductCrudService { private ProductRepository pr; public ProductCrudService(ProductRepository repository) { pr = repository; } public …

10 object-oriented-design  domain-driven-design  service  unique-data 

หนึ่งสัปดาห์ที่ผ่านมาฉันอยู่ที่LFNWและขณะที่ฉันกำลังพูดคุยกับ Larry Hastings หลังจากการพูดคุยของเขาเขาพูด (ถอดความ): มีบางอย่างใน Git ที่ทำให้กระบวนการดึงคำขอเป็นไปได้ที่ไม่มีอยู่ใน Mercurial นั่นเป็นเหตุผลที่คำขอการดึงใน BitBucket นั้นไม่ดี (สำหรับบริบทเรากำลังคุยกันถึงความจริงที่ว่า Python กำลังย้ายจาก Mercurial มาเป็น Git เนื่องจากเวิร์กโฟลว์ PR ไม่เหมือนกับเวิร์กโฟลว์ file-bug-then-attach-patch เขากำลังพูดถึงอะไรที่นี่? เราสองคนไม่สามารถสร้างชื่ออะไรก็ได้ ฉันค้นหาเว็บโดยไม่มีโชค

10 git  mercurial  pull-requests  bitbucket 

พื้นหลัง ฉันมีโครงการที่ขึ้นอยู่กับการใช้งานของอุปกรณ์ฮาร์ดแวร์บางประเภทในขณะที่มันไม่สำคัญว่าใครจะทำอุปกรณ์ฮาร์ดแวร์นั้นตราบเท่าที่มันเป็นสิ่งที่ฉันต้องทำ จากที่กล่าวมาแม้กระทั่งอุปกรณ์สองชิ้นที่ควรทำในสิ่งเดียวกันจะมีความแตกต่างเมื่อไม่ได้ผลิตโดยผู้ผลิตรายเดียวกัน ดังนั้นฉันจึงคิดว่าจะใช้อินเทอร์เฟซเพื่อแยกแอปพลิเคชันออกจากอุปกรณ์/ รุ่นที่เกี่ยวข้องและมีอินเทอร์เฟซที่ครอบคลุมฟังก์ชั่นระดับสูงสุดแทน นี่คือสิ่งที่ฉันคิดว่าสถาปัตยกรรมของฉันจะมีลักษณะ: กำหนดอินเตอร์เฟซใน C # IDeviceโครงการหนึ่ง มีรูปธรรมในห้องสมุดที่กำหนดไว้ในโครงการ C # อื่นที่จะใช้เพื่อเป็นตัวแทนของอุปกรณ์ มีอุปกรณ์ที่เป็นรูปธรรมใช้IDeviceอินเตอร์เฟซ IDeviceอินเตอร์เฟซที่อาจจะมีวิธีการเช่นหรือGetMeasurementSetRange ทำให้แอปพลิเคชันมีความรู้เกี่ยวกับรูปธรรมและส่งผ่านรูปธรรมไปยังรหัสแอปพลิเคชั่นที่ใช้งาน ( ไม่นำไปใช้ ) IDeviceอุปกรณ์ ฉันค่อนข้างแน่ใจว่านี่เป็นวิธีที่ถูกต้องที่จะไปเกี่ยวกับเรื่องนี้เพราะแล้วฉันจะสามารถเปลี่ยนอุปกรณ์ที่ใช้โดยไม่ส่งผลกระทบต่อแอปพลิเคชัน (ซึ่งดูเหมือนว่าจะเกิดขึ้นบางครั้ง) กล่าวอีกนัยหนึ่งมันไม่สำคัญว่าการใช้งานGetMeasurementหรือSetRangeทำงานผ่านคอนกรีตอย่างแท้จริง (อาจแตกต่างกันระหว่างผู้ผลิตอุปกรณ์) ข้อสงสัยเดียวในใจของฉันคือตอนนี้ทั้งแอปพลิเคชันและคลาสที่เป็นรูปธรรมของอุปกรณ์นั้นขึ้นอยู่กับไลบรารีที่มีIDeviceส่วนต่อประสาน แต่นั่นเป็นสิ่งที่ไม่ดี? ฉันไม่เห็นด้วยว่าแอปพลิเคชันไม่จำเป็นต้องรู้เกี่ยวกับอุปกรณ์ได้อย่างไรนอกจากอุปกรณ์และIDeviceอยู่ในเนมสเปซเดียวกัน คำถาม ดูเหมือนว่าวิธีการที่ถูกต้องสำหรับการใช้อินเทอร์เฟซเพื่อแยกการพึ่งพาระหว่างแอปพลิเคชันของฉันและอุปกรณ์ที่ใช้หรือไม่

10 c#  design-patterns  object-oriented  interfaces  dependency-management 

ฉันกำลังเขียนเกมใน typescript และตัดสินใจว่าจะลองทำตามแนวคิดของ " การเขียนโปรแกรมด้วยอินเตอร์เฟส " ซึ่งคุณเขียนโค้ดตามอินเตอร์เฟสแทนการใช้งานของวัตถุ ฉันเขียนอินเทอร์เฟซจำนวนมากและคลาสที่ใช้งานพวกเขาจากนั้นถอยกลับและตระหนักว่าคลาสนั้นง่ายพอที่ฉันจะไม่ต้องเปลี่ยนการใช้งานเนื่องจากมีวิธีเดียวที่จะทำสิ่งที่ คลาสทำ (เคลื่อนที่Phaser.Spriteในลักษณะที่ จำกัด เพื่อทำตัวเหมือนรถถัง) จากนั้นฉันจำได้ว่าได้อ่านเมื่อไม่กี่ปีที่ผ่านมาเกี่ยวกับแนวคิดของYAGNIซึ่งโดยพื้นฐานแล้วคุณไม่ควรสร้างรหัสของคุณมากเกินไปเพื่อรวมสิ่งที่คุณไม่เคยใช้ การปฏิบัติตามแนวทางปฏิบัติที่ดีที่สุดทุกคลาสควรใช้อินเทอร์เฟซหรือคุณควร จำกัด เฉพาะคลาสที่คุณคาดว่าจะมีการแลกเปลี่ยนในอนาคต

10 object-oriented-design  interfaces  patterns-and-practices 

ฟังก์ชั่นf()ใช้eval()(หรือบางสิ่งที่อันตราย) กับข้อมูลที่ฉันสร้างและเก็บไว้ในlocal_fileเครื่องที่ใช้โปรแกรมของฉัน: import local_file def f(str_to_eval): # code.... # .... eval(str_to_eval) # .... # .... return None a = f(local_file.some_str) f() ปลอดภัยที่จะเรียกใช้เนื่องจากสตริงที่ฉันกำหนดให้เป็นของฉันเอง แต่ถ้าฉันเคยตัดสินใจที่จะใช้มันสำหรับบางสิ่งบางอย่างที่ไม่ปลอดภัย (เช่นผู้ใช้ป้อนข้อมูล) สิ่งที่จะไปผิดมหันต์ นอกจากนี้หากlocal_fileหยุดเป็นท้องถิ่นแล้วมันจะสร้างช่องโหว่เนื่องจากฉันจะต้องเชื่อถือเครื่องที่ให้ไฟล์นั้นเช่นกัน ฉันจะแน่ใจได้อย่างไรว่าฉันไม่เคย "ลืม" ว่าฟังก์ชั่นนี้ไม่ปลอดภัยที่จะใช้ (เว้นแต่ว่าตรงตามเกณฑ์ที่กำหนด) หมายเหตุ: eval()มีอันตรายและมักจะถูกแทนที่ด้วยสิ่งที่ปลอดภัย

10 python  vulnerabilities 

ฉันใช้อัลกอริทึมซึ่งค่อนข้างซับซ้อนในการคำนวณและต้องการพยายามทำให้แน่ใจว่าฉันไม่ได้ทำงานที่ไม่จำเป็น มีโครงตาข่ายลูกบาศก์ nxnxn เช่นถ้า n = 2 ประกอบด้วย (0,0,0), (0,1,0), (1,0,0), (1,1,0), (0, 1,1), (0,0,1), (1,0,1), (1,1,1) จากขัดแตะนี้ฉันจะสร้างจุด m ซ้ำซ้ำทุกอย่างเช่น: solve(set_of_points) { if set_of_points.size = m, finish do some useful computation here for each point in lattice not in set_of_points: solve(set_of_points + new_point); } ซึ่งสามารถเรียกได้ว่าเริ่มต้นด้วย set_of_point ที่ว่างเปล่า ลักษณะของปัญหาที่เกิดขึ้นเป็นเช่นนั้นฉันไม่จริงต้องทุกการเปลี่ยนแปลงของจุดเมตรเพียงแค่คนที่เป็นเอกลักษณ์ภายใต้ symmetries ธรรมชาติของลูกบาศก์ …

10 algorithms  recursion 

ฉันมีฐานสองชั้นOperationและTrigger. แต่ละคนมีจำนวนคลาสย่อยที่เชี่ยวชาญในการดำเนินการหรือทริกเกอร์บางประเภท สามารถเรียกเฉพาะTrigger OperationขณะสามารถเรียกโดยเฉพาะเจาะจงOperationTrigger ฉันต้องเขียนโค้ดที่แม็พOperationกับที่ได้รับTrigger(หรือกลับกัน) แต่ฉันไม่แน่ใจว่าจะใส่ไว้ที่ไหน ในกรณีนี้รหัสไม่ได้เป็นของชั้นหนึ่งหรือชั้นอื่น ๆ อย่างชัดเจน ดังนั้นในแง่ของหลักการความรับผิดชอบเดี่ยวฉันไม่แน่ใจว่าควรจะใช้รหัสใด ฉันเห็นตัวเลือกสามตัวที่ใช้งานได้ทั้งหมด ในขณะที่ 1 & 2 ดูเหมือนจะเป็นทางเลือกของซีแมนทิกส์ แต่ 3 หมายถึงแนวทางที่แตกต่างอย่างสิ้นเชิง bool Triggers(Operation o)ทริกเกอร์เช่น bool TriggeredBy(Trigger t)วิธีการใช้งานเช่น bool MappingExists(Trigger t, Operation o)ในระดับใหม่ทั้งหมดซึ่งจัดการการทำแผนที่เช่น ฉันจะตัดสินใจได้อย่างไรว่าจะวางรหัสการแมปที่ใช้ร่วมกันอย่างไรในหลักการความรับผิดชอบเดียว วิธีการจัดการความรับผิดชอบเดียวเมื่อมีการแบ่งปันความรับผิดชอบ? แก้ไข 1 ดังนั้นรหัสจริงจะเป็นแบบนี้ คุณสมบัติทั้งหมดที่มีอย่างใดอย่างหนึ่งstring, Guid, หรือcollection<string> enumโดยพื้นฐานแล้วพวกเขาเป็นเพียงตัวแทนของข้อมูลขนาดเล็ก แก้ไข 2 สาเหตุของการส่งคืนชนิดบูล ชั้นอื่นจะไปกินคอลเลกชันของและคอลเลกชันของTrigger Operationมันต้องการที่จะทราบว่าการทำแผนที่ที่มีอยู่ระหว่างและTrigger Operationมันจะใช้ข้อมูลนั้นเพื่อสร้างรายงาน

10 object-oriented  single-responsibility 

พยายามเรียนรู้ Clojure และคุณอดไม่ได้ที่จะได้รับการบอกเล่าอย่างต่อเนื่องว่า Clojure เป็นข้อมูลที่ไม่เปลี่ยนรูปแบบหรือไม่ แต่คุณสามารถกำหนดตัวแปรใหม่ได้อย่างง่ายดายโดยใช้defใช่มั้ย ฉันเข้าใจว่านักพัฒนา Clojure หลีกเลี่ยงสิ่งนี้ แต่คุณสามารถหลีกเลี่ยงการเปลี่ยนแปลงตัวแปรในภาษาใดก็ได้เหมือนกัน บางคนสามารถอธิบายให้ฉันฟังได้ว่าสิ่งนี้แตกต่างกันอย่างไรเพราะฉันคิดว่าฉันขาดมันไปจากบทเรียนและหนังสือที่ฉันอ่าน เพื่อยกตัวอย่างว่าเป็นอย่างไร a = 1 a = 2 ใน Ruby (หรือร้องไห้สะอึกสะอื้นหากคุณต้องการ) แตกต่างจาก (def a 1) (def a 2) ใน Clojure

10 clojure 

เนื่องจาก Python อนุญาตให้ใช้การสืบทอดหลายแบบการถ่ายทอดทางพันธุกรรมใน Python มีลักษณะอย่างไร ในภาษาที่มีการสืบทอดเดียวเช่น Java การสืบทอดจะถูกใช้เมื่อคุณสามารถพูดได้ว่าวัตถุหนึ่ง "is-a" ของวัตถุอื่นและคุณต้องการแบ่งปันรหัสระหว่างวัตถุ (จากวัตถุหลักไปยังวัตถุลูก) ตัวอย่างเช่นคุณสามารถพูดได้ว่าDogเป็นAnimal: public class Animal {...} public class Dog extends Animal {...} แต่เนื่องจาก Python รองรับการสืบทอดหลายแบบเราจึงสามารถสร้างวัตถุโดยการรวมวัตถุอื่นเข้าด้วยกัน ลองพิจารณาตัวอย่างด้านล่าง: class UserService(object): def validate_credentials(self, username, password): # validate the user credentials are correct pass class LoggingService(object): def log_error(self, error): # log an error pass …

10 object-oriented  python  inheritance  multiple-inheritance 

พิจารณาสถานการณ์ที่คลาสใช้พฤติกรรมพื้นฐานวิธีการและอื่น ๆ แต่คลาสที่แตกต่างกันของคลาสนั้นอาจมีอยู่สำหรับการใช้ที่แตกต่างกัน ในกรณีเฉพาะของฉันฉันมีเวกเตอร์ (เวกเตอร์เรขาคณิตไม่ใช่รายการ) และเวกเตอร์นั้นสามารถใช้ได้กับพื้นที่ยูคลิดมิติ N- มิติใด ๆ (1 มิติ, 2 มิติ, ... ) คลาส / ประเภทนี้สามารถกำหนดได้อย่างไร? นี่จะเป็นเรื่องง่ายใน C ++ ที่เทมเพลตของคลาสสามารถมีค่าจริงเป็นพารามิเตอร์ได้ แต่เราไม่มีความหรูหราใน Java ทั้งสองวิธีที่ฉันสามารถคิดได้ว่าสามารถนำมาใช้เพื่อแก้ปัญหานี้คือ: มีการดำเนินการของแต่ละกรณีที่เป็นไปได้ในเวลารวบรวม public interface Vector { public double magnitude(); } public class Vector1 implements Vector { public final double x; public Vector1(double x) { this.x = …

10 java  design-patterns  code-generation 

ดังนั้นฉันจึงมีโรงงานที่สร้างวัตถุของคลาสที่แตกต่างกัน คลาสที่เป็นไปได้ทั้งหมดมาจากบรรพบุรุษที่เป็นนามธรรม โรงงานมีไฟล์กำหนดค่า (ไวยากรณ์ JSON) และตัดสินใจว่าจะสร้างคลาสใดขึ้นอยู่กับการกำหนดค่าของผู้ใช้ เพื่อให้บรรลุสิ่งนี้โรงงานใช้ boost :: property_tree สำหรับ JSON-parsing เขาเดินผ่านต้นไม้ต้นทรีและตัดสินใจเลือกวัตถุที่เป็นรูปธรรมเพื่อสร้าง อย่างไรก็ตามผลิตภัณฑ์วัตถุมีหลายฟิลด์ (คุณลักษณะ) วัตถุมีคุณสมบัติประมาณ 5-10 ตัวในอนาคตอาจมีมากกว่านี้ขึ้นอยู่กับคลาสที่เป็นรูปธรรม ดังนั้นฉันไม่แน่ใจว่าตัวสร้างของวัตถุควรมีลักษณะอย่างไร ฉันสามารถคิดถึงวิธีแก้ปัญหาสองข้อ: 1) ตัวสร้างของผลิตภัณฑ์คาดว่าทุกแอตทริบิวต์เป็นพารามิเตอร์ดังนั้นตัวสร้างจะลงท้ายด้วยพารามิเตอร์ 10+ สิ่งนี้จะน่าเกลียดและนำไปสู่บรรทัดโค้ดที่ยาวและอ่านไม่ได้ อย่างไรก็ตามข้อดีคือโรงงานสามารถแยกวิเคราะห์ JSON และเรียกใช้ตัวสร้างด้วยพารามิเตอร์ที่ถูกต้อง คลาสผลิตภัณฑ์ไม่จำเป็นต้องรู้ว่าถูกสร้างขึ้นเนื่องจากการกำหนดค่า JSON ไม่จำเป็นต้องรู้ว่ามี JSON หรือการกำหนดค่าที่เกี่ยวข้องเลย 2) คอนสตรัคเตอร์ของผลิตภัณฑ์คาดว่าจะมีอาร์กิวเมนต์เดียวคือออบเจ็กต์ property_tree จากนั้นมันก็สามารถแยกวิเคราะห์ข้อมูลที่จำเป็น หากข้อมูลในการกำหนดค่าขาดหายไปหรือไม่อยู่ในขอบเขตของแต่ละคลาสผลิตภัณฑ์สามารถตอบสนองได้อย่างถูกต้อง โรงงานไม่จำเป็นต้องทราบว่าผลิตภัณฑ์หลายตัวต้องการข้อโต้แย้งใด โรงงานยังไม่จำเป็นต้องรู้วิธีการตอบสนองในกรณีที่มีการกำหนดค่าผิดพลาด และอินเทอร์เฟซตัวสร้างเป็นปึกแผ่นและเล็ก แต่ในฐานะที่เป็นข้อเสียผลิตภัณฑ์จำเป็นต้องดึงข้อมูลที่ต้องการจาก JSON ดังนั้นจึงรู้ได้ว่ามันถูกสร้างขึ้นอย่างไร ฉันมักจะชอบโซลูชัน 2) อย่างไรก็ตามฉันไม่แน่ใจว่านี่เป็นรูปแบบโรงงานที่ดีหรือไม่ รู้สึกผิดอย่างใดอย่างหนึ่งที่ทำให้ผลิตภัณฑ์ทราบว่าสร้างขึ้นด้วยการกำหนดค่า JSON ในอีกด้านหนึ่งผลิตภัณฑ์ใหม่สามารถแนะนำง่ายมาก ความคิดเห็นใด …

10 design-patterns  object-oriented  c++  architectural-patterns  factory-method 

เรามีวัตถุ public class MyObject{ protected MyObject(){} public string Property1 {get;private set;} public string Property2 {get;private set;} public string Property3 {get;private set;} public string Property4 {get;private set;} public string Property5 {get;private set;} public string Property6 {get;private set;} public string Property7 {get;private set;} public string Property8 {get;private set;} public string Property9 {get;private …

10 c#  testing  constructors  setters 

ผู้ให้บริการสถาปัตยกรรมคอมพิวเตอร์ใหม่พยายามแนะนำรูปแบบการเขียนโปรแกรมใหม่อย่างสม่ำเสมอเช่นเมื่อเร็ว ๆ นี้ CUDA / OpenCL สำหรับ GPGPU และแทนที่ C / POSIX เป็นอินเทอร์เฟซการควบคุมไปยังแพลตฟอร์มแบบคู่ขนาน (Poss & Koening, AM3: สู่ตัวเร่งความเร็ว Unix สำหรับหลายคอร์, 2015) ทำไมนักออกแบบสถาปัตยกรรมจึงพยายามออกแบบโมเดลการเขียนโปรแกรมใหม่เพื่อแทนที่ C / POSIX สำหรับการคำนวณแบบขนาน C / POSIX ไม่เหมาะกับมัลติโปรเซสเซอร์หรือผู้เขียนต้นฉบับของ C / POSIX ไม่จำเป็นต้องใช้การคำนวณแบบขนานในการออกแบบ C / POSIX หรือไม่? หรือเป็นกรณีที่โปรแกรมเมอร์ต้องการความสามารถมากกว่า C / POSIX ที่สามารถส่งมอบได้ดังนั้นจึงหันไปใช้การออกแบบใหม่เช่น CUDA / OpenCL เป็นต้น

10 architecture  multithreading  parallelism  posix 

ฉันสงสัยว่าการทำสำเนาการเขียนมีประโยชน์อะไรบ้าง โดยธรรมชาติแล้วฉันไม่ได้คาดหวังกับความคิดเห็นส่วนตัว แต่เป็นสถานการณ์จริงที่สามารถนำไปใช้ได้จริงในทางที่เป็นรูปธรรมและเป็นประโยชน์ และโดยจับต้องได้ฉันหมายถึงบางสิ่งที่มากกว่าการช่วยให้คุณพิมพ์&อักขระได้ เพื่อชี้แจงคำถามนี้อยู่ในบริบทของประเภทข้อมูลที่การสร้างการมอบหมายหรือคัดลอกสร้างสำเนาตื้นโดยปริยาย แต่การแก้ไขมันจะสร้างสำเนาลึกโดยนัยและใช้การเปลี่ยนแปลงไปแทนวัตถุต้นฉบับ เหตุผลที่ฉันถามคือฉันดูเหมือนจะไม่พบข้อดีของการมี COW เป็นพฤติกรรมเริ่มต้นโดยปริยาย ฉันใช้ Qt ซึ่งมีการใช้งาน COW สำหรับประเภทข้อมูลจำนวนมากซึ่งเกือบทั้งหมดมีพื้นที่จัดเก็บข้อมูลที่จัดสรรแบบไดนามิก แต่มันมีประโยชน์ต่อผู้ใช้อย่างไรจริงๆ? ตัวอย่าง: QString s("some text"); QString s1 = s; // now both s and s1 internally use the same resource qDebug() << s1; // const operation, nothing changes s1[o] = z; // s1 "detaches" from s, …

10 c++  qt 

ฉันอ่านใบอนุญาต LGPLและพบข้อกำหนดที่ฉันไม่เคยรู้มาก่อน ส่วนที่ 4 (ผลงานรวม) ระบุว่า: คุณอาจนำเสนอ Combined Work [... ] หากคุณทำสิ่งต่อไปนี้ด้วย: a) ให้คำบอกกล่าวที่เด่นชัดพร้อมกับสำเนาของงานรวมแต่ละชุดที่มีการใช้งานห้องสมุดและห้องสมุดและการใช้งานนั้นได้รับการคุ้มครองโดยใบอนุญาตนี้ b) ใช้งานร่วมกับสำเนา GNU GPLและเอกสารสัญญาอนุญาตนี้ ค) ... ทำไม GPL ต้องถูกถ่ายทอดเมื่อทำการเชื่อมโยงไปยังไลบรารี่ที่ได้รับอนุญาตภายใต้ LGPL ด้วย? ฉันกลัวว่าการรวมทั้งสิทธิ์ใช้งานทั้งสองในการแจกจ่ายจะสร้างความสับสนให้ผู้ใช้ว่าจะใช้กับสิ่งใด ฉันตีความสิ่งนี้ถูกต้องหรือไม่? ถ้าเป็นเช่นนั้นอะไรคือเหตุผลที่อยู่เบื้องหลังข้อกำหนดนี้?

10 licensing  open-source  gpl  lgpl