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

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

23 architecture  testing  development-methodologies 

ทีมมากกว่าที่ LMAX มีการนำเสนอเกี่ยวกับวิธีการที่พวกเขาสามารถที่จะทำ100k TPS ที่น้อยกว่า 1 มิลลิวินาทีแฝง พวกเขาได้รับการสนับสนุนขึ้นนำเสนอที่มีบล็อก , กระดาษทางเทคนิค (PDF)และรหัสที่มาของตัวเอง เมื่อเร็ว ๆ นี้มาร์ตินฟาวเลอร์ได้ตีพิมพ์บทความที่ยอดเยี่ยมเกี่ยวกับสถาปัตยกรรม LMAXและระบุว่าตอนนี้พวกเขาสามารถจัดการคำสั่งได้หกล้านคำสั่งต่อวินาทีและเน้นขั้นตอนบางอย่างที่ทีมทำเพื่อเพิ่มขนาดของประสิทธิภาพ จนถึงตอนนี้ฉันได้อธิบายแล้วว่ากุญแจสู่ความเร็วของ Business Logic Processor กำลังทำทุกอย่างตามลำดับในหน่วยความจำ เพียงแค่ทำสิ่งนี้ (และไม่มีอะไรโง่จริงๆ) ให้นักพัฒนาสามารถเขียนโค้ดที่สามารถประมวลผล 10K TPS จากนั้นพวกเขาพบว่าการมุ่งเน้นไปที่องค์ประกอบง่ายๆของรหัสที่ดีสามารถนำสิ่งนี้มาสู่ช่วง 100K TPS สิ่งนี้ต้องการเพียงรหัสที่ได้รับการรับรองและวิธีการเล็ก ๆ เท่านั้นซึ่งสิ่งนี้จะช่วยให้ฮอตสปอตทำงานได้ดีขึ้นในการเพิ่มประสิทธิภาพและเพื่อให้ซีพียูมีประสิทธิภาพมากขึ้นในการแคชโค้ดขณะที่ทำงานอยู่ ความฉลาดเพิ่มขึ้นอีกเล็กน้อยเพื่อให้ได้ลำดับความสำคัญมากขึ้น มีหลายสิ่งที่ทีม LMAX พบว่าเป็นประโยชน์ในการเดินทาง หนึ่งคือการเขียนการใช้งานที่กำหนดเองของคอลเลกชัน Java ที่ได้รับการออกแบบให้เป็นมิตรกับแคชและระมัดระวังกับขยะ อีกเทคนิคในการเข้าถึงระดับสูงสุดของประสิทธิภาพคือให้ความสนใจในการทดสอบประสิทธิภาพ ฉันสังเกตเห็นมานานแล้วว่าผู้คนพูดถึงเทคนิคต่าง ๆ มากมายเพื่อปรับปรุงประสิทธิภาพ แต่สิ่งหนึ่งที่สร้างความแตกต่างได้จริงๆคือการทดสอบ ฟาวเลอร์กล่าวว่ามีหลายสิ่งที่พบ แต่เขาพูดถึงเพียงคู่ มีสถาปัตยกรรมห้องสมุดเทคนิคหรือ "สิ่ง" อื่น ๆ ที่มีประโยชน์ในการเข้าถึงระดับประสิทธิภาพดังกล่าวหรือไม่

23 java  architecture  performance 

ฉันกำลังทำงานกับแอปพลิเคชัน 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 

ฉันกำลังพยายามเขียนเว็บไซต์ธุรกิจ "มาตรฐาน" โดย "มาตรฐาน" ฉันหมายถึงเว็บไซต์นี้ใช้ HTML5, CSS และ Javascript ปกติสำหรับ front-end, back-end (เพื่อประมวลผลข้อมูล) และรัน MySQL สำหรับฐานข้อมูล มันเป็นเว็บไซต์ CRUD ขั้นพื้นฐาน: Front-end ทำสิ่งที่ฐานข้อมูลมีอยู่ แบ็กเอนด์เขียนไปยังฐานข้อมูลอะไรก็ตามที่ผู้ใช้ป้อนและทำการประมวลผลบางอย่าง เช่นเดียวกับไซต์ส่วนใหญ่ที่ออกมี ในการสร้างที่เก็บ Github ของฉันที่จะเริ่มต้นการเข้ารหัส, ฉันได้ตระหนักถึงฉันไม่เข้าใจความแตกต่างระหว่างfront-end หลังสิ้นสุดและAPI อีกวิธีในการใช้คำถามของฉันคือ: API เข้ามาในรูปภาพนี้ที่ไหน ฉันจะเขียนรายละเอียดเพิ่มเติมจากนั้นคำถามที่ฉันมี - หวังว่านี่จะช่วยให้พวกคุณมีความคิดที่ดีขึ้นว่าคำถามจริงของฉันคืออะไรเพราะฉันสับสนจนฉันไม่รู้คำถามที่จะถาม รายละเอียดเพิ่มเติมบางส่วน: ฉันต้องการลองใช้รูปแบบ Model-View-Controller ฉันไม่รู้ว่านี่เป็นการเปลี่ยนแปลงคำถาม / คำตอบหรือไม่ API จะสงบ ฉันต้องการให้back-end ของฉันใช้ API ของตัวเองแทนการอนุญาตให้ back-end โกงและโทรสอบถามพิเศษ ฉันคิดว่าสไตล์นี้มีความสอดคล้องมากกว่า คำถามของฉัน: …

23 design  web-development  architecture  terminology 

ผมชอบแนวคิดในวิดีโอหลักการสะอาดสถาปัตยกรรมโดยลุงบ๊อบมาร์ติน แต่ฉันรู้สึกว่ารูปแบบนี้เหมือนกับการรวมกันของรูปแบบนามธรรมจากโรงงานและตัวสร้างที่แกนกลางของมัน นี่เป็นวิธีหนึ่งในการเขียนโปรแกรมที่ดี แต่ไม่ใช่วิธีเดียว Rails และ reactjs เป็น 2 เฟรมเวิร์กที่มาพร้อมกับจิตใจที่ไม่สนับสนุนสถาปัตยกรรมที่สะอาดเช่นนี้ Rails คาดว่าตรรกะทางธุรกิจของคุณจะอยู่ในรูปแบบ ( FatModels และ SkinnyControllers ) และตอบสนองภายในองค์ประกอบของคุณ ทั้งสองวิธีทั้งคู่แน่นตรรกะทางธุรกิจและรหัสกรอบ ฉันไม่พบสิ่งผิดปกติใน 3 วิธี มันเป็นการตัดสินใจที่จะเลือกใคร แต่ในวิดีโอฉันรู้สึกว่าเขาแนะนำว่าสถาปัตยกรรมสะอาดควรมีขอบเขตที่ชัดเจนระหว่างตรรกะทางธุรกิจและกรอบงาน Frameworks (เว็บแอนดรอยด์ ฯลฯ ) ควรเป็นปลั๊กอินที่เชื่อมต่อกับตรรกะทางธุรกิจ เขายังแยกรางรถไฟในวิดีโออย่างละเอียด ดังนั้น"Clean Architecture" โดย Bob Martin เป็นกฎง่ายๆสำหรับสถาปัตยกรรมทั้งหมดหรือเป็นเพียงหนึ่งในตัวเลือกหรือไม่

22 architecture 

มีความแตกต่างทางสถาปัตยกรรมที่สำคัญหรือไม่เมื่อออกแบบแอพพลิเคชั่นที่จะสร้างด้วยภาษาแบบสแตติก (เช่น C # หรือ Java) และภาษาแบบไดนามิก (เช่น Ruby หรือ Python) ความเป็นไปได้ในการออกแบบที่อาจเป็นตัวเลือกที่ดีสำหรับประเภทหนึ่งที่ไม่ดีสำหรับอีกประเภทหนึ่งคืออะไร มีคุณสมบัติที่มีประโยชน์ใด ๆ ที่สามารถใช้งานได้กับประเภทหนึ่งที่ไม่ได้อยู่กับคุณสมบัติอื่น (ในการออกแบบและสถาปัตยกรรม) นอกจากนี้ยังมีรูปแบบการออกแบบเฉพาะแบบไดนามิกหรือไม่

22 design  architecture  dynamic-typing  static-typing 

มีแนวทางใดบ้างในการตัดสินใจว่าคลาสควรอยู่ในชุด / DLL ของตัวเองหรือไม่? ฉันมักจะเห็นโรงเรียนแห่งความคิดสองแห่ง: 1) "การจัดกลุ่ม" ของคลาสทุกคลาสนั้นอยู่ใน DLL ของตัวเองเช่นที่เก็บบริการ DTO โครงสร้างพื้นฐานเป็นต้น 2) ทุกอย่างควรอยู่ใน DLL เดียว แต่แยกออกจาก namespaces / folder เช่นมี "Core" DLL ที่มี namespaces เพิ่มเติมเช่น Core.Repositories, Core.Services, Core.DTO เป็นต้น ที่ทำงานเราเพิ่งรวบรวมทุกอย่างในสภาเดียวที่เรียกว่า "ธุรกิจ" มีบางโฟลเดอร์ แต่ไม่มีการแยกที่แท้จริง - วัตถุทางธุรกิจ (ด้วยตรรกะซึ่งบางอันไม่ควรเป็นคลาส) จะถูกรวมเข้าในโฟลเดอร์ "BusinessObjects" โดยไม่สนใจ สิ่งที่ใช้ในคลาสมากกว่าหนึ่งอยู่ในโฟลเดอร์ "Core" ยูทิลิตี้อยู่ในโฟลเดอร์ "ยูทิลิตี้" โครงสร้างพื้นฐานการเข้าถึงข้อมูลคือโฟลเดอร์ "ข้อมูล" - คุณจะได้รับแนวคิด สำหรับโมดูลใหม่ที่ฉันกำลังทำงานอยู่ฉันต้องการ / …

22 c#  architecture  directory-structure 

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

22 algorithms  architecture  parallel-programming 

ฉันกำลังประเมิน CMS โอเพนซอร์สที่ชื่อว่า Piranha ( http://piranhacms.org/ ) เพื่อใช้ในโครงการใดโครงการหนึ่งของฉัน ฉันพบรหัสต่อไปนี้น่าสนใจและสับสนเล็กน้อยอย่างน้อยสำหรับฉัน บางอย่างช่วยให้ฉันเข้าใจได้หรือไม่ว่าทำไมห้องเรียนถึงได้รับมรดกจากประเภทเดียวกัน? public abstract class BasePage<T> : Page<T> where T : BasePage<T> { /// <summary> /// Gets/sets the page heading. /// </summary> [Region(SortOrder = 0)] public Regions.PageHeading Heading { get; set; } } ถ้าชั้นBasePage<T>จะถูกกำหนดไว้ทำไมสืบทอดมาจากPage<T> where T: BasePage<T>? มีจุดประสงค์เฉพาะอะไรบ้าง

21 c#  architecture  .net  cms 

ตัวอย่างด้านล่างเป็นสิ่งประดิษฐ์โดยสิ้นเชิงและจุดประสงค์เพียงอย่างเดียวคือเพื่อให้ได้จุดของฉัน สมมติว่าฉันมีตาราง SQL: CREATE TABLE rectangles ( width int, height int ); ระดับโดเมน: public class Rectangle { private int width; private int height; /* My business logic */ public int area() { return width * height; } } ตอนนี้สมมติว่าฉันมีความต้องการที่จะแสดงให้ผู้ใช้เห็นพื้นที่ทั้งหมดของรูปสี่เหลี่ยมผืนผ้าทั้งหมดในฐานข้อมูล ฉันสามารถทำได้โดยดึงแถวทั้งหมดของตารางเปลี่ยนเป็นวัตถุและวนซ้ำไปมา แต่มันดูโง่มากเพราะฉันมีรูปสี่เหลี่ยมผืนผ้ามากมายในตาราง ดังนั้นฉันทำสิ่งนี้: SELECT sum(r.width * r.height) FROM rectangles r ง่ายรวดเร็วและใช้จุดแข็งของฐานข้อมูล …

21 architecture  maintainability 

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

21 architecture  agile  database  persistence 

ฉันมักจะพบว่าตัวเองกำลังเขียนฟังก์ชั่นที่มีลักษณะเช่นนี้เพราะพวกเขาทำให้ฉันสามารถเข้าถึงข้อมูลได้อย่างง่ายดายและยังมีลายเซ็นที่ยอมรับพารามิเตอร์เพื่อกำหนดข้อมูลที่จะเข้าถึง public static string GetFormattedRate( Func<string, RateType>> getRate, string rateKey) { var rate = getRate(rateKey); var formattedRate = rate.DollarsPerMonth.ToString("C0"); return formattedRate; } หรือ public static string GetFormattedRate( Func<RateType, string> formatRate, Func<string, RateType>> getRate, string rateKey) { var rate = getRate(rateKey); var formattedRate = formatRate(rate); return formattedRate; } จากนั้นฉันก็ใช้สิ่งนี้: using FormatterModule; …

20 c#  architecture  functional-programming 

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

20 design  architecture  uml  modeling 

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

20 architecture  coding-standards 

เป็นที่รู้จักกันดีสำหรับผู้ที่คุ้นเคยกับประวัติที่ C # และ. NET Framework เริ่มต้นจากการที่ "Delphi เขียนใหม่เพื่อให้รู้สึกเหมือน Java" ได้รับการออกแบบโดยหัวหน้าผู้พัฒนาที่อยู่เบื้องหลัง Delphi, Anders Hejlsberg สิ่งต่าง ๆ ได้เบี่ยงเบนไปเล็กน้อยตั้งแต่นั้นมา แต่ในช่วงต้นของความคล้ายคลึงกันได้ชัดเจนว่ามีการเก็งกำไรร้ายแรงบางอย่างที่. NET เป็นผลิตภัณฑ์ดั้งเดิมของ Borland แต่ฉันได้ดูบางสิ่ง. NET เมื่อเร็ว ๆ นี้และหนึ่งในคุณสมบัติที่น่าสนใจและมีประโยชน์ที่สุดจาก Delphi ดูเหมือนจะหายไปโดยสิ้นเชิง: แนวคิดของคลาสเป็นประเภทข้อมูลชั้นหนึ่ง สำหรับผู้ที่ไม่คุ้นเคยกับมันประเภทTClassแสดงถึงการอ้างอิงถึงระดับคล้ายกับTypeประเภทใน. NET แต่ที่. NET ใช้Typeในการสะท้อนเดลฟีใช้TClassเป็นส่วนสำคัญในตัวของภาษา มันช่วยให้สำนวนที่เป็นประโยชน์ต่าง ๆ ที่ไม่มีและไม่มีอยู่จริงเช่นตัวแปรคลาสย่อยและวิธีคลาสเสมือน ทุกภาษา OO มีวิธีการเสมือนซึ่งคลาสที่แตกต่างกันใช้แนวคิดพื้นฐานเดียวกันของวิธีการในวิธีที่ต่างกันและจากนั้นวิธีการที่เหมาะสมจะได้รับการเรียกใช้ที่รันไทม์ตามชนิดที่แท้จริงของอินสแตนซ์วัตถุที่เรียกว่า Delphi ขยายแนวคิดนี้ไปยังคลาส: ถ้าคุณมีการอ้างอิง TClass ที่กำหนดเป็นคลาสย่อยเฉพาะ (เช่นclass of TMyClassหมายความว่าตัวแปรสามารถรับการอ้างอิงคลาสใด ๆ ที่สืบทอดมาTMyClassแต่ไม่ใช่สิ่งใดนอก …

20 architecture  .net  history  delphi