คำถามติดแท็ก architecture

สมมติว่าคุณถูกถามในการสัมภาษณ์ "คุณจะใช้ Google Search อย่างไร" คุณจะตอบคำถามนี้อย่างไร อาจมีแหล่งข้อมูลที่อธิบายว่ามีการใช้งานชิ้นส่วนบางอย่างใน Google ได้อย่างไร (BigTable, MapReduce, PageRank, ... ) แต่ไม่เหมาะสำหรับการสัมภาษณ์ คุณจะใช้สถาปัตยกรรมใดโดยรวมและคุณจะอธิบายสิ่งนี้อย่างไรในช่วงเวลา 15-30 นาที ฉันจะเริ่มต้นด้วยการอธิบายวิธีสร้างเครื่องมือค้นหาที่จัดการกับเอกสาร ~ 100k แล้วขยายสิ่งนี้ด้วยการส่งผ่านเอกสารประมาณ 50 ล้านเอกสารจากนั้นอาจก้าวกระโดดทางสถาปัตยกรรม / ทางเทคนิคอื่น นี่คือมุมมอง 20,000 ฟุต สิ่งที่ฉันต้องการคือรายละเอียด - คุณจะตอบอย่างไรในการสัมภาษณ์ โครงสร้างข้อมูลใดที่คุณจะใช้ สถาปัตยกรรมของคุณประกอบด้วยบริการ / เครื่องจักรใด เวลาแฝงของแบบสอบถามทั่วไปจะเป็นอย่างไร สิ่งที่เกี่ยวกับปัญหา failover / split brain? ฯลฯ ...

44 design  algorithms  architecture  search 

สถาปัตยกรรมสะอาดแนะนำให้ให้โต้ตอบด้วยกรณีใช้เรียกใช้งานจริงของพรีเซนเตอร์ (ซึ่งถูกฉีดต่อไปนี้กรมทรัพย์สินทางปัญญา) เพื่อจัดการการตอบสนอง / จอแสดงผล อย่างไรก็ตามฉันเห็นคนที่ใช้สถาปัตยกรรมนี้ส่งคืนข้อมูลเอาต์พุตจากผู้โต้ตอบจากนั้นปล่อยให้คอนโทรลเลอร์ (ในชั้นอะแดปเตอร์) ตัดสินใจเลือกวิธีจัดการกับมัน โซลูชันที่สองรั่วไหลความรับผิดชอบของแอปพลิเคชันออกจากเลเยอร์แอปพลิเคชันนอกเหนือจากการกำหนดอินพุตและเอาต์พุตพอร์ตให้กับผู้โต้ตอบไม่ชัดเจนหรือไม่ พอร์ตอินพุตและเอาต์พุต เมื่อพิจารณาคำจำกัดความของ Clean Architectureและโดยเฉพาะอย่างยิ่งแผนภาพการไหลขนาดเล็กที่อธิบายความสัมพันธ์ระหว่างตัวควบคุมผู้ใช้เคสผู้โต้ตอบและผู้นำเสนอฉันไม่แน่ใจว่าฉันเข้าใจถูกต้องหรือไม่ว่าควรใช้ "พอร์ตเคสเอาต์พุต" อย่างไร สถาปัตยกรรมแบบคลีนเช่นสถาปัตยกรรมหกเหลี่ยมแยกความแตกต่างระหว่างพอร์ตหลัก (เมธอด) และพอร์ตรอง (อินเทอร์เฟซที่จะใช้งานโดยอะแดปเตอร์) ตามกระแสการสื่อสารฉันคาดหวังว่า "ใช้ Case Input Port" เป็นพอร์ตหลัก (ดังนั้นเป็นเพียงวิธีการ) และ "Use Case Output Port" เป็นอินเตอร์เฟสที่จะใช้งานอาจเป็นอาร์กิวเมนต์ตัวสร้างที่ใช้อะแดปเตอร์จริง เพื่อให้ผู้โต้ตอบสามารถใช้งานได้ ตัวอย่างรหัส ในการสร้างตัวอย่างโค้ดนี่อาจเป็นรหัสคอนโทรลเลอร์: Presenter presenter = new Presenter(); Repository repository = new Repository(); UseCase useCase = new UseCase(presenter, …

42 architecture  architectural-patterns  onion-architecture 

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

42 design  architecture  agile  scrum  team-leader 

ฉันเป็นนักพัฒนารุ่นน้อง (ประมาณ 3 ปี) และที่งานของฉันเรากำลังอยู่ระหว่างการออกแบบระบบใหม่ ผู้พัฒนาหลักของฉันจะเป็นสถาปนิกหลัก แต่เขาท้าทายให้ฉันลองสร้างระบบด้วยตัวเอง (ในแบบคู่ขนาน) ในช่วงไม่กี่ครั้งของการระดมความคิดและเสนอสิ่งที่ฉันเห็นว่าเป็นคำแนะนำด้านสถาปัตยกรรมผู้นำของฉันได้ให้ข้อเสนอแนะแก่ฉันว่าสิ่งที่ฉันทำส่วนใหญ่คือ "การออกแบบ" และไม่ใช่ "การออกแบบสถาปัตยกรรม" เขาอธิบายถึงความแตกต่างในขณะที่การใช้งานสถาปัตยกรรมไม่เชื่อเรื่องพระเจ้าในขณะที่การออกแบบเป็นคำอธิบายของการดำเนินการ เขาบอกว่าฉันต้องถอดหมวกออกแบบและสวมหมวกสถาปนิกของฉัน เขาให้คำแนะนำเล็กน้อยกับฉันเกี่ยวกับการทำเช่นนั้น แต่ฉันอยากจะถามคุณเช่นกัน: ฉันจะออกจากโหมดผู้ออกแบบซอฟต์แวร์และเริ่มคิดเหมือนสถาปนิกได้อย่างไร ต่อไปนี้เป็นตัวอย่างของ "การออกแบบ" ที่ฉันเห็นว่าไม่เกี่ยวข้องกับสถาปัตยกรรมโดยผู้นำของฉัน: ฉันคิดอัลกอริทึมสำหรับการโหลดและการยกเลิกการโหลดทรัพยากรจากระบบของเราและลูกค้าของฉันบอกว่าอัลกอริทึมไม่ใช่สถาปัตยกรรม ฉันเกิดเหตุการณ์ต่าง ๆ ขึ้นมาระบบควรจะเพิ่มและสิ่งที่มันควรจะยกระดับ แต่สิ่งนี้ก็ดูเหมือนจะไม่ตัดเป็นสถาปัตยกรรม ฉันดูเหมือนจะจมอยู่กับรายละเอียดและก้าวถอยหลังไม่ไกลพอ ฉันพบว่าแม้เมื่อฉันคิดอะไรบางอย่างที่อยู่ในระดับสถาปัตยกรรมฉันก็มักจะไปถึงที่นั่นด้วยการลองใช้งานที่หลากหลายและการล้อเล่นรายละเอียดจากนั้นทำการสรุปและสรุป เมื่อฉันอธิบายสิ่งนี้กับผู้นำของฉันเขาบอกว่าฉันใช้วิธีการที่ผิด: ฉันต้องคิดว่า "จากบนลงล่าง" และไม่ใช่ "ลงล่าง" นี่คือรายละเอียดเฉพาะเพิ่มเติมเกี่ยวกับโครงการ : โครงการที่เราออกแบบคือเว็บแอปพลิเคชั่น ฉันประมาณรหัสประมาณ 10,000 บรรทัด เราเริ่มแล้ว ทีมวิศวกรของเราประมาณ 3-5 คน สิ่งที่ใกล้เคียงที่สุดที่ฉันสามารถเปรียบเทียบใบสมัครของเราคือ CMS ที่มีน้ำหนักเบา มันมีความซับซ้อนและข้อตกลงคล้ายกันส่วนใหญ่กับการโหลดและการขนถ่ายส่วนประกอบการจัดการเลย์เอาต์และโมดูลสไตล์ปลั๊กอิน แอปพลิเคชันคือ Ajax-y ผู้ใช้ดาวน์โหลดไคลเอ็นต์หนึ่งครั้งจากนั้นร้องขอข้อมูลตามที่ต้องการจากเซิร์ฟเวอร์ เราจะใช้รูปแบบ …

42 design  architecture 

ฉันเพิ่งมาโดยปัญหาสถาปัตยกรรมที่ดูเหมือนเล็กน้อย ฉันมีพื้นที่เก็บข้อมูลอย่างง่ายในรหัสของฉันที่ถูกเรียกเช่นนี้ (รหัสเป็น C #): var user = /* create user somehow */; _userRepository.Add(user); /* do some other stuff*/ _userRepository.SaveChanges(); SaveChanges เป็น wrapper ง่ายๆที่ยอมรับการเปลี่ยนแปลงในฐานข้อมูล: void SaveChanges() { _dataContext.SaveChanges(); _logger.Log("User DB updated: " + someImportantInfo); } หลังจากนั้นครู่หนึ่งฉันจำเป็นต้องใช้ตรรกะใหม่ที่จะส่งการแจ้งเตือนทางอีเมลทุกครั้งที่ผู้ใช้ถูกสร้างขึ้นในระบบ เนื่องจากมีการโทรเข้า_userRepository.Add()และออกSaveChangesจากระบบจำนวนมากฉันจึงตัดสินใจอัปเดตSaveChangesดังนี้: void SaveChanges() { _dataContext.SaveChanges(); _logger.Log("User DB updated: " + someImportantInfo); foreach (var newUser …

40 architecture  single-responsibility  event 

ฉันกำลังทำงานผ่านการออกแบบ RESTful API เรารู้ว่าเราต้องการส่งคืน JSON และ XML สำหรับทรัพยากรที่กำหนด ฉันคิดว่าเราจะทำสิ่งนี้: GET /api/something?param1=value1 Accept: application/xml (or application/json) อย่างไรก็ตามมีบางคนที่ใช้ส่วนขยายสำหรับสิ่งนี้เช่น: GET /api/something.xml?parm1=value1 (or /api/something.json?param1=value1) อะไรคือการแลกเปลี่ยนกับวิธีการเหล่านี้? เป็นการดีที่สุดที่จะพึ่งพาส่วนหัวการยอมรับเมื่อไม่ได้ระบุนามสกุล แต่ให้เกียรตินามสกุลเมื่อระบุ? มีข้อเสียเปรียบกับวิธีการนั้นหรือไม่?

40 architecture  web-services  rest  http 

ฉันทำงานให้กับ บริษัท ใหญ่ (พนักงานมากกว่า 8,000 คน) เป็นเวลาเกือบ 2 ปีแล้วและได้รับการจ้างงานหลังจากเรียนจบหลักสูตร ทุกคนที่นี่ต้องจัดการรหัสประจำวันซึ่งมักจะออกแบบมาไม่ดีและเต็มไปด้วยแฮ็ก ในตอนแรกฉันเก็บข้อมูลไม่ดีพยายามอย่าวิพากษ์วิจารณ์สิ่งต่างๆ แต่สถานการณ์ตามที่ได้กลายเป็นเรื่องยากมากที่จะอยู่กับและดูเหมือนว่าไม่มีใครเต็มใจที่จะปรับปรุง / แทนที่เครื่องมือที่เราใช้ เพื่อให้ชัดเจนยิ่งขึ้นเรามี: เครื่องมือควบคุมแหล่งที่ล้าสมัย (Visual SourceSafe) makefiles เก่าธรรมดาที่รองรับเฉพาะการสร้างใหม่อย่างเต็มรูปแบบ .def ไฟล์ที่ต้องดูแลรักษาด้วยตนเองและแยกกันสำหรับสถาปัตยกรรมที่มีอยู่ทั้งหมด ส่วนหัวของเสาหินไฟล์และโครงการที่มีไฟล์ต่างกันน้อยมาก (แต่แต่ละไฟล์มีโค้ดประมาณ 3000 บรรทัดซึ่งบางครั้งก็ดูแลงานที่แตกต่างกันมาก) ไม่มีการใช้สิ่งอำนวยความสะดวกด้านภาษา "ใหม่" ( std::stringก็ไม่ใช่เรื่องใหม่ แต่ไม่มีใครยกเว้นฉันใช้) ฉันตัดสินใจไม่กี่เดือนที่ผ่านมาเพื่อทำอะไรกับมันโดยการออกแบบสภาพแวดล้อมการรวบรวมใหม่ ฉันสามารถสร้างบิวด์เพิ่มเติมเพื่อทำงานได้อย่างน่าเชื่อถือใช้เวลาในการคอมไพล์เร็วขึ้นสร้างโครงงานที่ดีกว่า.defสร้างไฟล์อัตโนมัติ ฉันยังสร้างบริดจ์จาก / ถึง Git ถึง / จาก Visual SourceSafe ฉันแสดงความสำเร็จของฉันต่อเพื่อนร่วมงานหลายคนและเจ้านายของเรา แต่ก็เหมือนไม่มีใครสนใจ พวกเขาทุกคนต่างก็พูดว่า "อืม ... ผู้คนเคยทำแบบนั้นแล้วทำไมเราจะเปลี่ยนสิ่งต่าง ๆ ? …

40 architecture  productivity  changes 

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

39 architecture  web-applications  domain-driven-design  microservices 

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

38 design  architecture  quality 

ฉันทำงานในโครงการที่ใช้ (Spring) Dependency Injection สำหรับทุกสิ่งที่เป็นที่พึ่งของชั้นเรียน เราอยู่ในจุดที่ไฟล์การกำหนดค่าของ Spring โตขึ้นประมาณ 4,000 บรรทัด เมื่อไม่นานมานี้ฉันได้ดูหนึ่งในการพูดคุยของลุงบ็อบบน YouTube (น่าเสียดายที่ฉันไม่สามารถหาลิงก์ได้) ซึ่งเขาแนะนำให้ฉีดการพึ่งพาจากศูนย์กลางเพียงไม่กี่คู่ (เช่นโรงงานฐานข้อมูล ... ) ลงในองค์ประกอบหลักจากนั้น แจกจ่าย ข้อดีของวิธีนี้คือการแยกส่วนของ DI Framework จากแอปพลิเคชั่นส่วนใหญ่และทำให้ Spring config Cleaner เป็นโรงงานจะมีสิ่งที่อยู่ใน config ก่อนหน้านี้ ในทางตรงกันข้ามสิ่งนี้จะส่งผลให้เกิดการแพร่กระจายตรรกะการสร้างในคลาสโรงงานจำนวนมากและการทดสอบอาจยากขึ้น ดังนั้นคำถามของฉันคืออะไรคือข้อดีหรือข้อเสียอื่น ๆ ที่คุณเห็นในแนวทางหนึ่งหรืออีกวิธีหนึ่ง มีวิธีปฏิบัติที่ดีที่สุดหรือไม่? ขอบคุณมากสำหรับคำตอบของคุณ!

38 architecture  dependency-injection 

ส่วนใหญ่ฉันเก็บการกำหนดค่าแอปพลิเคชันการพัฒนาในไดเรกทอรีรากของโครงการเช่นนี้ app |-- config.json แต่นั่นไม่ได้เป็นวิธีที่ดีที่สุดเนื่องจากการกำหนดค่านี้จะถูกเก็บไว้ในระบบควบคุมเวอร์ชัน - อาจส่งผลให้เกิดการรั่วไหลของชื่อผู้ใช้รหัสผ่านและข้อมูลที่ละเอียดอ่อนอื่น ๆ คู่มือแนะนำแอพ 12 Factorแนะนำให้วางไฟล์กำหนดค่าโดยรวมและใช้ตัวแปรสภาพแวดล้อมสำหรับการตั้งค่า: ... เก็บ config ในตัวแปรสภาพแวดล้อม Env vars สามารถเปลี่ยนแปลงได้ง่ายระหว่าง Deploys โดยไม่ต้องเปลี่ยนรหัสใด ๆ ต่างจากไฟล์ปรับแต่งมีโอกาสน้อยที่จะถูกตรวจสอบลงในรหัสซื้อคืนโดยไม่ได้ตั้งใจ และแตกต่างจากไฟล์ปรับแต่งที่กำหนดเองหรือกลไกการกำหนดค่าอื่น ๆ เช่นคุณสมบัติระบบ Java พวกเขาเป็นมาตรฐานภาษาและระบบปฏิบัติการไม่เชื่อเรื่องพระเจ้า ฟังดูดีสำหรับฉันจริง ๆ แต่ร้านใดร้านหนึ่งพูดว่าตัวแปรสภาพแวดล้อมโดยไม่ตรวจสอบสิ่งเหล่านั้นลงในการควบคุมแหล่งที่มา? และเครื่องมือใดที่ฉันสามารถใช้เพื่อส่งตัวแปรเหล่านั้นไปยังแอป สามารถมีตัวเลือกการกำหนดค่าได้หลายสิบตัวและพิมพ์ด้วยมือทุกครั้งที่คุณเปิดแอปไม่ดี - ดังนั้นจึงต้องเก็บไว้ในไฟล์บางประเภท ไฟล์ดังกล่าวจะจบลงในการควบคุมแหล่งและเรากลับไปที่ที่เราเริ่ม มีวิธีจัดการตัวเลือกการกำหนดค่าที่ยอมรับกันโดยทั่วไปหรือไม่ซึ่งไม่มีความเสี่ยงในการจัดเก็บการกำหนดค่าท้องถิ่นในการควบคุมแหล่งที่มา?

38 architecture  configuration  configuration-management 

ตามเอกสารของ Microsoft บทความ Wikipedia SOLID principe หรือสถาปนิกด้านไอทีส่วนใหญ่เราต้องตรวจสอบให้แน่ใจว่าแต่ละชั้นมีหน้าที่รับผิดชอบเพียงอย่างเดียว ฉันอยากจะรู้ว่าทำไมเพราะถ้าทุกคนดูเหมือนจะเห็นด้วยกับกฎนี้ดูเหมือนจะไม่มีใครเห็นด้วยกับเหตุผลของกฎนี้ บางคนกล่าวถึงการบำรุงรักษาที่ดีกว่าบางคนบอกว่าเป็นการทดสอบที่ง่ายหรือทำให้ชั้นเรียนมีความแข็งแกร่งมากขึ้นหรือมีความปลอดภัย อะไรถูกและจริงหมายถึงอะไร ทำไมจึงทำให้การบำรุงรักษาดีขึ้นการทดสอบง่ายขึ้นหรือรหัสมีเสถียรภาพมากขึ้น?

37 design-patterns  architecture  solid  single-responsibility 

ฉันเคยสร้างคลาส / วิธีการที่เป็นนามธรรมจำนวนมาก จากนั้นฉันก็เริ่มใช้อินเตอร์เฟส ตอนนี้ฉันไม่แน่ใจว่าอินเทอร์เฟซไม่ทำให้คลาสนามธรรมล้าสมัยหรือไม่ คุณต้องการคลาสที่เป็นนามธรรมอย่างสมบูรณ์หรือไม่ สร้างส่วนต่อประสานแทน คุณต้องการคลาสนามธรรมที่มีการใช้งานบางอย่างหรือไม่ สร้างอินเตอร์เฟสสร้างคลาส รับชั้นเรียนใช้อินเตอร์เฟซ ประโยชน์เพิ่มเติมคือบางคลาสอาจไม่ต้องการคลาสพาเรนต์ แต่จะใช้อินเตอร์เฟส ดังนั้นคลาส / เมธอด abstract ล้าสมัยหรือไม่?

37 object-oriented  architecture  inheritance  interfaces 

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

37 architecture  code-smell  quality 

ดวงจันทร์จำนวนมากหลายครั้งแล้วที่ฉันทำปริญญาโทของฉันในวิศวกรรมซอฟต์แวร์เชิงวัตถุ ฉันครอบคลุมทุกอย่าง: การเริ่มต้นโครงการ, ความต้องการ, การวิเคราะห์, ออกแบบ, สถาปัตยกรรม, การพัฒนา, ฯลฯ หนังสือเล่มโปรดของฉันตลอดเวลาคือการพัฒนาซอฟต์แวร์เชิงวัตถุ, แนวทางประสบการณ์ (IBM-1996) หนังสือที่สร้างขึ้นโดยกลุ่มผู้เชี่ยวชาญที่แท้จริงของเวลาของพวกเขา มันอธิบายวิธีการทำงานของผลิตภัณฑ์เป็นศูนย์กลางเพื่อการวิเคราะห์เชิงวัตถุการออกแบบและการพัฒนา ฉันออกแบบและพัฒนาและมีความสุขและเป็นจุดเริ่มต้นของเกมของฉัน แต่ฉันเริ่มรู้สึกล้าสมัยไปแล้ว: การเคลื่อนไหวแบบ Agile กลายเป็นแฟชั่นในวันนั้น ทันใดนั้นผู้พัฒนาที่ไม่มีประสบการณ์ก็เริ่มพูดพล่ามเมื่อฉันพูดว่า "ข้อกำหนด" หรือ "สถาปัตยกรรม" ราวกับว่าสิ่งเหล่านี้ถูกแทนที่ด้วยเวทมนตร์ การออกแบบและการพัฒนาสูญเสียไปอย่างสนุกและฉันกำลังจะออกจากอุตสาหกรรมไอทีทั้งหมดไปกับฉัน จากนั้นฉันก็ค้นพบสกาล่า โอ้เหมือนฝนนุ่ม ๆ บนถนนที่เต็มไปด้วยฝุ่น ทุกอย่างเพิ่งชัดเจนอากาศก็หวานอีกครั้งและแสงเล็ก ๆ ของฮาร์ดไดรฟ์ของฉันจะสั่นไหวลึกลงไปในยามค่ำคืนทำให้ฉันเป็นเพื่อนกันในโลกแห่งการค้นพบ ฉันชอบการออกแบบระบบ ฉันเป็นสถาปนิกที่สำคัญมากกว่าโปรแกรมเมอร์ ฉันรักการวิเคราะห์การออกแบบการคิดการโต้เถียงการปรับปรุง - ฉันรักการออกแบบที่เรียบง่ายสะอาดและกรอบ เราจะออกแบบโซลูชัน Scala บริสุทธิ์ได้อย่างไร ไดอะแกรมลำดับทั่วไปไดอะแกรมปฏิสัมพันธ์ไดอะแกรมวัตถุ ฯลฯ ทั้งหมดอาจถูกแทนที่หรือปรับปรุงเพื่อความดีของการผสมความจำเป็นและการทำงานของระบบที่มุ่งเน้นวัตถุ แน่นอนว่ามีบางสิ่งที่แตกต่างออกไปโดยสิ้นเชิง! ฉันไม่ได้มองหาความซับซ้อนป่อง - ฉันกำลังมองหาความเรียบง่ายที่มีความยืดหยุ่น เช่น Scala นั้นง่ายและง่าย …

35 scala  architecture