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

วันนี้ฉันได้พูดคุยกับเพื่อนร่วมงานเกี่ยวกับการตั้งชื่อfinalฟิลด์ในคลาส Java ในfinalฟิลด์โอปี้ของเขาควรได้รับการพิจารณาว่าเป็นค่าคงที่เนื่องจากค่าของมันจะไม่เปลี่ยนแปลงหลังจากการสร้างอินสแตนซ์ สิ่งนี้จะนำไปสู่หลักการตั้งชื่อต่อไปนี้สำหรับfinalฟิลด์: public class Foo { private static final String BLA_BLA = "bla"; private final String BAR_BATZ; ... } ในความเห็นของฉันstatic finalควรพิจารณาเฉพาะเขตข้อมูลในขณะที่เขตข้อมูลที่finalควรปฏิบัติตามหลักการตั้งชื่อ camelCase ตามปกติเท่านั้น public class Foo { private static final String BLA = "bla"; private final String barBatz; ... } ตอนนี้ฉันค่อนข้างไม่แน่ใจเพราะเขาเป็นโปรแกรมเมอร์ที่มีประสบการณ์มากกว่าฉันและฉันมักจะเห็นด้วยกับความคิดเห็นของเขาและถือว่าเขาเป็นนักพัฒนาที่ดีมาก ข้อมูลใด ๆ เกี่ยวกับเรื่องนี้?

23 java  naming  final 

ฉันออกแบบ REST API ที่ใช้งานได้จริงและฉันติดอยู่กับวิธีเพิ่มเอนทิตีที่มีอยู่ในคอลเลกชัน โมเดลโดเมนของฉันมีโครงการที่มีไซต์ต่างๆ นี่เป็นความสัมพันธ์แบบกลุ่มต่อกลุ่มที่เข้มงวดและฉันไม่จำเป็นต้องสร้างเอนทิตีที่จำลองความสัมพันธ์อย่างชัดเจน (เช่น ProjectSite) API ของฉันจะช่วยให้ผู้บริโภคสามารถเพิ่มเว็บไซต์ที่มีอยู่ในโครงการ ที่ที่ฉันต้องวางสายคือข้อมูลเดียวที่ฉันต้องการจริงๆคือ ProjectId และ SiteId แนวคิดเริ่มต้นของฉันคือ: 1. POST myapi/projects/{projectId}/sites/{siteId} แต่ฉันก็คิดถึง 2. POST myapi/projects/{projectId}/sites ด้วยเอนทิตีของไซต์ที่ส่งเป็นเนื้อหา JSON ตัวเลือกที่ 1 นั้นง่ายและใช้งานได้ แต่รู้สึกไม่ถูกต้องและฉันมีความสัมพันธ์อื่น ๆ ที่ไม่สามารถทำตามรูปแบบนี้ดังนั้นมันจึงเพิ่มความไม่สอดคล้องกับ API ของฉัน ตัวเลือก 2 รู้สึกดีขึ้น แต่นำไปสู่ข้อกังวลสองข้อ: ฉันควรสร้างเว็บไซต์หรือส่งข้อยกเว้นหากมีการโพสต์ไซต์ใหม่ (SiteId = 0) เนื่องจากฉันต้องการเพียง ProjectId และ SiteId เพื่อสร้างความสัมพันธ์ไซต์อาจถูกโพสต์ด้วยข้อมูลที่ผิดหรือขาดหายไปสำหรับคุณสมบัติอื่น ๆ ตัวเลือกที่ 3 คือการจัดเตรียมจุดปลายอย่างง่ายเพียงอย่างเดียวสำหรับการสร้างและลบความสัมพันธ์ จุดสิ้นสุดนี้คาดว่าจะมี …

23 rest  api-design 

รูปแบบโรงงาน (หรืออย่างน้อยใช้FactoryFactory..) เป็นก้นของตลกจำนวนมากเช่นที่นี่ นอกเหนือจากการมี verbose และชื่อ "สร้างสรรค์" เช่น RequestProcessorFactoryFactory.RequestProcessorFactoryแล้วมีอะไรผิดปกติกับรูปแบบของโรงงานถ้าคุณต้องโปรแกรมใน Java / C ++ และมี usecase สำหรับAbstract_factory_pattern ? ภาษายอดนิยมอื่นจะทำอย่างไร (เช่นRubyหรือScala ) จะหลีกเลี่ยงการใช้ภาษาในขณะที่จัดการความซับซ้อนที่คล้ายกันได้อย่างไร เหตุผลที่ฉันถามคือฉันเห็นคำวิจารณ์ส่วนใหญ่ของโรงงานที่กล่าวถึงในบริบทของระบบนิเวศJava / Java EEแต่พวกเขาไม่เคยอธิบายว่าภาษา / กรอบอื่น ๆ แก้ปัญหาได้อย่างไร

23 java  design-patterns 

ฉันมีคำถามง่าย ๆ ที่ทำให้ฉันงุนงงมานาน ฉันกำลังจัดการกับเครือข่ายและฐานข้อมูลดังนั้นข้อมูลจำนวนมากที่ฉันกำลังเผชิญอยู่คือเคาน์เตอร์ 32- บิตและ 64- บิต (ไม่ได้ลงนาม), id รหัส 32- บิตและ 64- บิต (ยังไม่มีแผนที่ที่มีความหมายสำหรับการลงชื่อเข้าใช้) ฉันไม่เคยจัดการกับคำศัพท์จริงใด ๆ ที่สามารถแสดงเป็นจำนวนลบได้ ฉันและเพื่อนร่วมงานของฉันมักใช้ประเภทที่ไม่ได้ลงนามเช่นuint32_tและuint64_tสำหรับเรื่องเหล่านี้และเพราะมันเกิดขึ้นบ่อยครั้งเราจึงใช้พวกเขาสำหรับดัชนีแถวลำดับและการใช้จำนวนเต็มทั่วไปอื่น ๆ ในขณะเดียวกันคู่มือการเข้ารหัสต่างๆที่ฉันกำลังอ่าน (เช่น Google) ไม่สนับสนุนการใช้ประเภทจำนวนเต็มที่ไม่ได้ลงชื่อและเท่าที่ฉันทราบว่า Java หรือ Scala ไม่มีประเภทจำนวนเต็มที่ไม่ได้ลงนาม ดังนั้นฉันไม่สามารถหาสิ่งที่ถูกต้องได้: การใช้ค่าที่มีการเซ็นชื่อในสภาพแวดล้อมของเราจะไม่สะดวกมากในเวลาเดียวกันในขณะเดียวกันแนวทางการเข้ารหัสเพื่อยืนยันในการทำสิ่งนี้

23 c  coding-style 

ในแอสเซมบลีค่อนข้างมากคำสั่งการคัดลอกค่ามักจะชื่อ "MOV" และคำอธิบายในคู่มือมักจะมี "ย้าย" (อย่างไรก็ตามคำอื่น ๆ สามารถใช้เช่น "โหลด", "เก็บ", "เก็บ", "แยก" ฯลฯ ) ) เป็นเรื่องแปลกที่จะหาISA ) ที่ไม่ปฏิบัติตามอนุสัญญานี้ ในทางตรงกันข้ามในบริบทอื่น ๆ "ย้าย" แตกต่างจาก "คัดลอก" ในแง่ที่แหล่งที่ถูกทำลาย (ตัวอย่างเช่น "mv" กับ "cp" ใน Unix ย้าย [F6] ในนอร์ตันผู้บัญชาการและโคลน ฯลฯ ) "การย้าย" ของ Assembler มีความหมาย "การคัดลอก" จริง ๆ ทำให้ค่าของแหล่งข้อมูลครบถ้วน ฉันพบว่าสิ่งนี้เริ่มต้นอย่างน้อยตั้งแต่IBM 1401 (1959) แต่IBM 360ใช้คำนี้เฉพาะสำหรับการคัดลอกในหน่วยเก็บข้อมูล แต่ไม่ได้สำหรับการดำเนินการระหว่างการลงทะเบียนและหน่วยเก็บข้อมูล (ซึ่งใช้ "load" …

23 history  assembly 

ฉันไม่ได้เรียนรู้การเขียนโปรแกรมที่โรงเรียนและฉันไม่ได้ทำงานในฐานะนักพัฒนา (มืออาชีพ) ดังนั้นพื้นฐานมากมายจึงไม่ค่อยชัดเจนสำหรับฉัน คำถามนี้พยายามที่จะอธิบายอย่างใดอย่างหนึ่ง ตอนนี้ขอสมมติว่าผมมีปัญหา#1, #2และ#3ในประเด็นการติดตามของฉันที่มีการกำหนดให้การแก้ไข / ปรับปรุงสำหรับรุ่น1.0.0และว่าที่ผ่านมา (มีเสถียรภาพ) 0.9.0เวอร์ชันคือ ฉันควรเพิ่มรุ่นเป็นเมื่อ1.0.0ใด เมื่อใดก) ปัญหาข้อใดข้อหนึ่งที่กล่าวข้างต้นถูกปิดหรือข) เมื่อปัญหาทั้งหมดที่เกี่ยวข้องกับรุ่น1.0ถูกปิด? วิธีไหนที่ถูกต้องที่จะทำ? และโดยวิธีที่ถูกต้องฉันหมายถึงสิ่งที่ใช้ในอุตสาหกรรมในปัจจุบัน

23 versioning  semantic-versioning 

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

23 object-oriented  functional-programming  class 

เรื่องการจัดรูปแบบรหัส แม้เรื่องการเยื้อง และความมั่นคงมีความสำคัญมากกว่าการปรับปรุงเล็กน้อย แต่โครงการมักจะไม่มีคู่มือสไตล์ชัดเจนชัดเจนตรวจสอบได้และบังคับใช้ตั้งแต่วันที่ 1 และการปรับปรุงที่สำคัญอาจมาถึงทุกวัน บางทีคุณอาจพบว่า SELECT id, name, address FROM persons JOIN addresses ON persons.id = addresses.person_id; อาจเขียนได้ดีกว่า / เขียนได้ดีกว่า SELECT persons.id, persons.name, addresses.address FROM persons JOIN addresses ON persons.id = addresses.person_id; ในขณะที่ทำงานเพื่อเพิ่มคอลัมน์เพิ่มเติมในแบบสอบถาม บางทีนี่อาจเป็นคำถามที่ซับซ้อนที่สุดในทั้งสี่ข้อความในรหัสของคุณหรือข้อความค้นหาเล็กน้อยในหมู่คนนับพัน ไม่ว่าการเปลี่ยนแปลงจะทำได้ยากเพียงใดคุณตัดสินใจได้ว่ามันคุ้มค่า แต่คุณจะติดตามการเปลี่ยนแปลงของรหัสในการเปลี่ยนแปลงการจัดรูปแบบที่สำคัญได้อย่างไร คุณเพียงแค่ยอมแพ้และพูดว่า "นี่คือจุดที่เราเริ่มต้นอีกครั้ง" หรือคุณสามารถฟอร์แมตแบบสอบถามทั้งหมดในประวัติพื้นที่เก็บข้อมูลทั้งหมด หากคุณใช้ระบบควบคุมเวอร์ชันแบบกระจายเช่น Git คุณสามารถย้อนกลับไปสู่การคอมมิทครั้งแรกและฟอร์แมตใหม่จากที่นี่ไปเป็นสถานะปัจจุบัน แต่มันเป็นงานจำนวนมากและทุกคนจะต้องหยุดทำงานชั่วคราว (หรือเตรียมพร้อมสำหรับแม่ของการรวมทั้งหมด) ในขณะที่มันกำลังดำเนินอยู่ มีวิธีที่ดีกว่าในการเปลี่ยนประวัติศาสตร์ซึ่งให้ผลลัพธ์ที่ดีที่สุด: สไตล์เดียวกันในทุกการกระทำ ผสานงานน้อยที่สุด …

23 version-control  coding-style  indentation 

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

23 agile  waterfall 

เพิ่งผ่านภาพนิ่งบางส่วนและสังเกตว่าแคช L1 (อย่างน้อยใน CPU ของ Intel) แยกความแตกต่างระหว่างข้อมูลและแคชคำสั่งฉันอยากจะรู้ว่าทำไมนี่คือ ..

23 hardware  cpu 

รูปแบบ JSON ใดเป็นตัวเลือกที่ดีกว่าสำหรับคู่ของค่าคีย์และทำไม [{"key1": "value1"}, {"key2": "value2"}] หรือ: [{"Name": "key1", "Value": "value1"}, {"Name": "key2", "Value": "value2"}] หรือ: {"key1": "value1", "key2": "value2"} ตัวแปรแรกดูเหมือนกะทัดรัดและ "ความหมายเชิงความหมาย" มากขึ้น ตัวแปรที่สองนั้นมีโครงสร้างที่เท่าเทียมกันมากขึ้นซึ่งอาจช่วยในการประมวลผล ตัวแปรที่ 3 ดูเหมือนจะมีความหมายมากยิ่งขึ้น คู่ค่าคีย์จะถูกใช้เพื่อแนบข้อมูลโดยพลการกับรายการอื่น ๆ ข้อมูลจะต้องต่อเนื่องกันเป็น JSON เพื่อปัดเศษข้อมูลผ่านระบบ

23 json 

ฉันกำลังทำงานกับแอปพลิเคชัน Spring-MVC ที่เราใช้ Maven สำหรับการจัดการการพึ่งพา เนื่องจากโครงการมีขนาดใหญ่เราจึงคิดแยกโครงการออกเป็นหลายส่วน ฉันมีข้อสงสัยบางอย่างซึ่งฉันหวังว่าจะได้รับคำตอบที่นี่ ขณะนี้เรากำลังปรับใช้ไฟล์ WAR ไฟล์เดียวเช่นเดียวROOT.warกับ Apache tomcat บนเซิร์ฟเวอร์ของเรา เนื่องจากโครงการมีขนาดใหญ่จึงมีบางส่วนในเว็บแอปเช่นการแจ้งเตือนและอีเมลบริการของบุคคลที่สาม PUSH (Cometd) REST API และอื่น ๆ ปัจจุบันทั้งหมดของพวกเขาอยู่ในสโมสรและขึ้นอยู่กับกันและกัน ตัวอย่างเช่นNotificationวัตถุยังขึ้นอยู่กับPersonวัตถุเนื่องจากการแจ้งเตือนนั้นได้รับการปรับแต่งสำหรับผู้ใช้ จุดประสงค์หลักของการแยกโครงการขนาดใหญ่คือการสามารถทำงานกับแต่ละโมดูลเพื่อแก้ไขข้อผิดพลาดการเพิ่มคุณสมบัติการทดสอบ ฯลฯ และเมื่อพอใจแล้วโมดูลนี้เท่านั้นที่สามารถถูกแทนที่บนเซิร์ฟเวอร์แทนแอปพลิเคชันทั้งหมด เป็นไปได้ไหม อย่างที่ฉันได้พูดไปแล้วก่อนหน้านี้มีการพึ่งพาและการจับคู่ระหว่างวัตถุ สิ่งเหล่านั้นจะได้รับการจัดการในโมดูลย่อยที่แตกต่างกันอย่างไรหรือเพียงแค่งบการนำเข้าจะเปลี่ยนเพื่อรวมโครงการอื่น ๆ ดังที่ฉันได้กล่าวไว้ความตั้งใจคือการทำงานกับแต่ละโมดูลและสามารถปรับใช้ (ดีกว่าร้อนกว่า) ปัจจุบันเรามีไฟล์ WAR ไฟล์เดียวROOT.warเท่านั้น การแยกจะสร้างไฟล์ war หลายไฟล์ซึ่งจะถูกเรียกโดย URL ว่าdomain-name.com/module_name/some_mapping? ขณะนี้ฉันกำลังตรวจสอบเอกสาร แต่นี่คือวัตถุประสงค์หลักที่เราต้องการบรรลุด้วยโมดูลที่จัดทำโดย Maven และสนใจที่จะรู้ว่าสิ่งนี้เป็นไปได้หรือไม่ หากมีข้อมูลเพิ่มเติมใด ๆ ที่จำเป็นโปรดแจ้งให้เราทราบ ขณะนี้ฉันกำลังใช้ POM ผู้ปกครองจากฤดูใบไม้ผลิดังนี้: <parent> …

23 java  design  architecture  web-development  maven 

ก่อนอื่นฉันรู้ว่านี่ไม่ใช่คำถามสไตล์คำถาม & คำตอบที่สมบูรณ์แบบด้วยคำตอบที่สมบูรณ์ แต่ฉันไม่สามารถคิดถ้อยคำใด ๆ ที่จะทำให้มันดีขึ้น ฉันไม่คิดว่าจะมีวิธีแก้ปัญหาที่สมบูรณ์สำหรับเรื่องนี้และนี่คือหนึ่งในเหตุผลที่ฉันโพสต์ไว้ที่นี่แทนที่จะเป็น Stack Overflow เมื่อเดือนที่แล้วฉันได้เขียนรหัสเซิร์ฟเวอร์ (mmorpg) ที่ค่อนข้างเก่าเพื่อให้ทันสมัยและง่ายต่อการขยาย / ดัดแปลง ฉันเริ่มต้นด้วยส่วนเครือข่ายและใช้ห้องสมุดบุคคลที่สาม (libevent) เพื่อจัดการสิ่งต่าง ๆ สำหรับฉัน ด้วยการเปลี่ยนแฟคตอริ่งและการเปลี่ยนรหัสใหม่ฉันได้แนะนำคอร์รัปชั่นหน่วยความจำบางแห่งและฉันพยายามดิ้นรนหาว่ามันเกิดอะไรขึ้น ฉันดูเหมือนจะไม่สามารถทำซ้ำได้อย่างน่าเชื่อถือบนสภาพแวดล้อมการพัฒนา / การทดสอบของฉันแม้ว่าจะใช้บอตแบบดั้งเดิมเพื่อจำลองการโหลดบางอย่างฉันจะไม่เกิดข้อผิดพลาดอีกต่อไป (ฉันแก้ไขปัญหาเรื่องเสรีภาพซึ่งทำให้บางสิ่ง) ฉันได้ลองแล้ว: Valgrinding นรกออกมาจากมัน - ไม่มีการเขียนที่ไม่ถูกต้องจนกว่าสิ่งที่จะเกิดปัญหา (ซึ่งอาจใช้เวลา 1+ วันในการผลิต .. หรือเพียงหนึ่งชั่วโมง) ซึ่งทำให้ฉันงงงันจริง ๆ ในบางครั้งมันจะเข้าถึงหน่วยความจำที่ไม่ถูกต้อง โอกาส? (มีวิธีการ "กระจาย" ช่วงที่อยู่หรือไม่) เครื่องมือวิเคราะห์รหัส ได้แก่ ความครอบคลุมและ cppcheck ในขณะที่พวกเขาชี้ให้เห็นถึง .. ความร้ายกาจและคดีขอบในรหัสไม่มีอะไรร้ายแรง บันทึกกระบวนการจนกว่ามันจะล้มเหลวด้วย gdb …

23 c++  debugging  memory 

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

23 java  terminology 

คำถามนี้ถูกโยกย้ายจาก Stack Overflow เพราะสามารถตอบได้ใน Software Engineering Stack Exchange อพยพ 8 ปีที่ผ่านมา ฉันแค่ไตร่ตรองเกี่ยวกับrand()ฟังก์ชั่นPHP และคิดเกี่ยวกับวิธีที่ฉันสามารถสร้างมันขึ้นมาใหม่และฉันก็ประหลาดใจอย่างสมบูรณ์ เครื่องกำเนิดตัวเลขสุ่มทำงานอย่างไร

23 random  numbers