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

ฉันกำลังพยายามสร้างแอพพลิเคชั่นรายการสิ่งที่ต้องทำง่ายๆด้วย PHP, MySQL, Jquery templating และ JSON ... อย่างไรก็ตามโครงสร้างของฉันดูเหมือนจะซับซ้อนกว่าใน JSON วิธีที่ดีที่สุดที่จะทำคืออะไร? ตารางใหม่สำหรับแต่ละรายการที่มีรายการ หรือ ตารางสำหรับรายการและตารางสำหรับรายการที่เข้าร่วมอย่างใด เพราะฉันได้ลองสิ่งนี้แล้วและดูเหมือนว่ามันจะไม่ถูกใช่มั้ย ตัวอย่างhttp://jsfiddle.net/Lto3xuhe/

15 database  database-design 

ฉันมีแผนที่ดังต่อไปนี้: Map<Double, List<SoundEvent>> soundEventCells = new HashMap<Double, List<SoundEvent>>(); นี้HashMapแมdoubleค่า (ซึ่งเป็นคะแนนในเวลา) เพื่อที่สอดคล้องกันSoundEvent'มือถือ': แต่ละเซลล์สามารถมีจำนวนSoundEvents นั่นเป็นสาเหตุที่มันถูกนำมาใช้เป็นList<SoundEvent>เพราะนั่นคือสิ่งที่มันเป็น เพื่อประโยชน์ในการอ่านรหัสได้ดีขึ้นฉันจึงคิดถึงการใช้คลาสภายในแบบคงที่ที่ง่ายมากเช่น: private static class SoundEventCell { private List<SoundEvent> soundEvents = new ArrayList<SoundEvent>(); public void addEvent(SoundEvent event){ soundEvents.add(event); } public int getSize(){ return soundEvents.size(); } public SoundEvent getEvent(int index){ return soundEvents.get(index); } // .. remove() method unneeded } …

15 java  design  object-oriented 

ฉันรู้ว่านี่เป็นวิธีปฏิบัติที่ถกเถียงกัน แต่สมมติว่านี่เป็นตัวเลือกที่ดีที่สุดสำหรับฉัน ฉันสงสัยเกี่ยวกับเทคนิคที่แท้จริงในการทำสิ่งนี้ วิธีการที่ฉันเห็นคือ: 1) สร้างคลาสเพื่อนที่เป็นคลาสที่ฉันต้องการทดสอบ 2) ในคลาสเพื่อนสร้างวิธีสาธารณะที่เรียกวิธีส่วนตัวของคลาสที่ทดสอบ 3) ทดสอบวิธีสาธารณะของเพื่อนชั้น นี่เป็นตัวอย่างง่ายๆที่แสดงให้เห็นถึงขั้นตอนข้างต้น: #include <iostream> class MyClass { friend class MyFriend; // Step 1 private: int plus_two(int a) { return a + 2; } }; class MyFriend { public: MyFriend(MyClass *mc_ptr_1) { MyClass *mc_ptr = mc_ptr_1; } int plus_two(int a) // Step …

15 c++  unit-testing  class  c++11 

ฉันขอโทษถ้าสิ่งนี้ดูเหมือนจะเป็นคำถามที่เกิดขึ้นซ้ำแล้วซ้ำอีก แต่ทุกครั้งที่ฉันพบบทความเกี่ยวกับหัวข้อนั้นส่วนใหญ่จะพูดถึงว่า DI คืออะไร ดังนั้นฉันได้รับ DI แต่ฉันพยายามที่จะเข้าใจความต้องการภาชนะ IoC ซึ่งทุกคนดูเหมือนว่าจะเข้ามา จุดประสงค์ของคอนเทนเนอร์ IoC จริง ๆ แล้วเป็นเพียง "การแก้ไขอัตโนมัติ" การใช้งานที่เป็นรูปธรรมของการพึ่งพาหรือไม่ บางทีชั้นเรียนของฉันมีแนวโน้มที่จะไม่ได้ขึ้นต่อกันหลายครั้งและนั่นอาจเป็นเหตุผลว่าทำไมฉันไม่เห็นเรื่องใหญ่ แต่ฉันต้องการให้แน่ใจว่าฉันเข้าใจถึงประโยชน์ของภาชนะอย่างถูกต้อง โดยทั่วไปแล้วฉันแบ่งตรรกะทางธุรกิจของฉันออกเป็นคลาสที่อาจมีลักษณะเช่นนี้: public class SomeBusinessOperation { private readonly IDataRepository _repository; public SomeBusinessOperation(IDataRespository repository = null) { _repository = repository ?? new ConcreteRepository(); } public SomeType Run(SomeRequestType request) { // do work... var results …

15 c#  dependency-injection  inversion-of-control  ioc-containers 

ฉันกำลังสร้าง. NET 4.5 C # Web API RESTful solution และฉันต้องการให้ใครบางคนบอกฉันว่าโซลูชันโครงการของฉันนั้นถูกต้องและ / หรือฉลาด (- เพียงพอหรือยัง) สำหรับโซลูชั่นที่ออกแบบโดยใช้ Domain Driven Design โปรด โซลูชันได้แบ่งออกเป็น 6 โครงการ: /ฐาน (ไม่ได้อ้างอิงอะไรเลย) โครงการเว็บและสร้างส่วนต่อประสานระหว่างโซลูชันกับโลกภายนอก มีตัวควบคุม Web API ไม่มีเหตุผลใดเลยในการรวบรวมค่าจากวัตถุที่ร้องขอและขอให้ BizApi ทำงานได้ /Biz.Api (อ้างอิงโดยฐาน]) ให้บริการโดเมนและอนุญาตให้ / โครงการอินเทอร์เฟซฐานสามารถเข้าถึงวัตถุตรรกะทางธุรกิจของโดเมนในโครงการ /Biz.Domain /Biz.Domain (อ้างอิงโดย Biz.Api) จัดเตรียมคลาสโดเมนสำหรับเลเยอร์ Biz.Api เหล่านี้มีวิธีการจัดการข้อมูลของธุรกิจในหน่วยความจำ /Dal.Db (อ้างอิงโดย Biz.Api) เลเยอร์ที่เก็บฐานข้อมูล เข้าถึงฐานข้อมูลและแมปข้อมูลที่ส่งคืนไปยัง DTO ภายในที่กำหนดในเลเยอร์ …

15 c#  rest  domain-driven-design 

ฉันเพิ่งพบฟังก์ชันนี้ในโครงการที่ฉันทำงานอยู่: -- Just returns the text unchanged. -- Note: <text> may be nil, function must return nil in that case! function Widget:wtr(text) return text end น่าเศร้าที่ผู้ทำรหัสไม่ทำงานใน บริษัท อีกต่อไป ทำไมหนึ่งจะสร้างฟังก์ชั่นที่ไม่ทำอะไรเลย แต่ส่งกลับพารามิเตอร์ที่เรียกว่าด้วย? มีการใช้ฟังก์ชันดังกล่าวไม่ได้ระบุตัวอย่างนี้ แต่โดยรวมในกรณีใด ๆ ? เนื่องจาก function aFunction(parameter) return parameter end จบลงแล้ว aFunction(parameter) == parameter ทำไมฉันต้องเขียนอะไรบางอย่าง aFunction(parameter) == whatIWantToCheck แทน parameter …

15 functions  parameters  lua  method-chaining 

ฉันไม่พบคำอธิบายเชิงลึกใด ๆ บนเว็บเกี่ยวกับการเปรียบเทียบระหว่างElasticSearchกับฐานข้อมูลกราฟ ทั้งสองได้รับการปรับให้เหมาะกับข้อมูลการสำรวจ ดูเหมือนว่า ElasticSearch จะได้รับการปรับให้เหมาะกับการวิเคราะห์ อย่างไรก็ตาม Neo4j ยังใช้ Lucene ในการจัดการดัชนีและคุณสมบัติ fulltext ทำไมฉันถึงต้องใช้ ElasticSearch ถ้าฉันใช้ฐานข้อมูลกราฟอยู่แล้ว? ในกรณีของฉันฉันใช้Neo4jเพื่อสร้างเครือข่ายสังคม ElasticSearch อาจนำประโยชน์อะไรมาให้จริง อัพเดท ---------- ฉันเพิ่งพบย่อหน้านี้: มีหลายกรณีที่ elasticsearch เป็นประโยชน์ กรณีการใช้งานบางอย่างเรียกร้องให้ชัดเจนกว่ากรณีอื่น ๆ รายการด้านล่างนี้เป็นงานบางส่วนที่ใช้งานการค้นหาด้วยยาง ค้นหาคำอธิบายผลิตภัณฑ์จำนวนมากเพื่อหาคู่ที่ดีที่สุดสำหรับวลีที่เฉพาะเจาะจง (พูดว่า "มีดเชฟ") และส่งคืนผลลัพธ์ที่ดีที่สุด จากตัวอย่างก่อนหน้านี้ทำลายแผนกต่างๆที่มี“ มีดเชฟ” ปรากฏขึ้น (ดูการเผชิญหน้าในภายหลังในหนังสือเล่มนี้) ค้นหาข้อความสำหรับคำที่ดูเหมือน "ฤดู" เติมคำในช่องค้นหาโดยอัตโนมัติตามคำที่พิมพ์บางส่วนโดยอ้างอิงจากการค้นหาที่ออกมาก่อนหน้าในขณะที่คิดคำสะกดผิด การจัดเก็บข้อมูล semi-Structured (JSON) จำนวนมากในรูปแบบที่กระจายด้วยระดับความซ้ำซ้อนที่ระบุในคลัสเตอร์ของเครื่องจักร อย่างไรก็ตามควรสังเกตว่าในขณะที่อีลาสติครีทรีทเป็นผู้แก้ปัญหาดังกล่าวได้ดีก็ไม่ใช่ทางเลือกที่ดีที่สุดสำหรับผู้อื่น มันไม่ดีเป็นพิเศษในการแก้ปัญหาซึ่งฐานข้อมูลเชิงสัมพันธ์ได้รับการปรับปรุง ปัญหาเช่นที่ระบุไว้ด้านล่าง การคำนวณจำนวนสินค้าที่เหลืออยู่ในสินค้าคงคลัง การหาผลรวมของรายการโฆษณาทั้งหมดในใบแจ้งหนี้ทั้งหมดที่ส่งออกในเดือนที่กำหนด การดำเนินการการดำเนินการสองรายการด้วยการสนับสนุนการย้อนกลับ การสร้างบันทึกที่รับประกันว่าจะไม่ซ้ำกันในหลาย …

15 database  query  graph-databases  elasticsearch 

มีการถกเถียงกันเล็กน้อยเกี่ยวกับโครงสร้างโครงการเริ่มต้น (โดยใช้ Maven / Eclipse) สำหรับแอปพลิเคชัน Java ขนาดใหญ่ ตัวเลือกที่ 1: entities (i.e. the whole database using Hibernate classes-first) services (i.e. sets of read/write operations on the entities) app (perhaps split up more further down the line) ตัวเลือก 2: area1-entities area1-services area1-app area2-entities area2-services area2-app ... (where area1, area2 etc. are …

15 java  eclipse  spring  hibernate  maven 

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

15 design-patterns  object-oriented  functions 

ฉันทำงานเฉพาะแอปพลิเคชันฝั่งไคลเอ็นต์ (โดยเฉพาะมือถือ) โดยใช้ Android ซึ่งระบบเครือข่ายทั้งหมดได้รับการจัดการที่เลเยอร์ HTTP โดยใช้เฟรมเวิร์กที่มีส่วนประกอบต่างๆเช่น HttpUrlConnection แต่ระบบการส่งข้อความแบบพุชเช่น Websockets / XMPP ฯลฯ ทั้งหมดรักษาการเชื่อมต่อแบบถาวรกับเซิร์ฟเวอร์ แม้แต่ GCM ของ Google ซึ่งอบลงในอุปกรณ์ที่รองรับ Google Play ยังคงรักษาการเชื่อมต่อกับเซิร์ฟเวอร์อย่างต่อเนื่อง คำถามของฉันคือทำงานได้อย่างไรโดยไม่ต้องใช้แบตเตอรี่หมด หากเราทำการร้องขอ HTTP อย่างต่อเนื่องตามลำดับการระบายแบตเตอรี่จะมีความสำคัญ การเชื่อมต่อแบบถาวรเหล่านี้มีวิธีการดูแลอย่างไรโดยไม่ประสบปัญหาเดียวกัน

15 networking  sockets 

ฉันได้อ่านเอกสารประกอบและหัวข้อคำถามอื่น ๆเกี่ยวกับหัวข้อนี้และฉันไม่รู้สึกมั่นใจจริงๆ ฉันไม่เห็นข้อ จำกัด ของการใช้เทคนิคนี้อย่างชัดเจน เศษจะเห็นในขณะนี้เป็นวิธีที่ดีที่สุด ; ทุกกิจกรรมควรเป็นส่วนสนับสนุนอย่างน้อยหนึ่งแฟรกเมนต์และไม่เรียกเลย์เอาต์โดยตรง แฟรกเมนต์ถูกสร้างขึ้นเพื่อ: อนุญาตให้Activityใช้ชิ้นส่วนจำนวนมากเปลี่ยนระหว่างหน่วยเหล่านี้เพื่อนำหน่วยเหล่านี้กลับมาใช้ใหม่ ... ==> Fragmentทั้งหมดขึ้นอยู่กับContextกิจกรรมดังนั้นหากฉันต้องการสิ่งทั่วไปที่ฉันสามารถนำมาใช้ใหม่และจัดการกับกิจกรรมมากมายฉันสามารถ สร้างเลย์เอาต์ที่กำหนดเองของตัวเองหรือมุมมอง ... ฉันจะไม่สนใจเกี่ยวกับเลเยอร์การพัฒนาความซับซ้อนเพิ่มเติมที่ชิ้นส่วนจะเพิ่ม การจัดการความละเอียดที่แตกต่างกันดีกว่า ==> ตกลงสำหรับแท็บเล็ต / โทรศัพท์ในกรณีที่กระบวนการที่ยาวนานซึ่งเราสามารถแสดงสองชิ้น (หรือมากกว่า) ในกิจกรรมเดียวกันในแท็บเล็ตและหนึ่งต่อหนึ่งในโทรศัพท์ แต่ทำไมฉันถึงต้องใช้แฟรกเมนต์เสมอ ? การจัดการการเรียกกลับเพื่อนำทางระหว่าง Fragments (เช่น: หากผู้ใช้เข้าสู่ระบบฉันจะแสดงส่วนอื่นฉันแสดงส่วนอื่น) ===> เพียงแค่ลองดูว่ามีข้อบกพร่องมากมายในการลงชื่อเข้าใช้ SDK ของ Facebook เพราะเหตุนี้เพื่อให้เข้าใจว่าเป็นจริง (?) ... การพิจารณาว่าแอปพลิเคชัน Android นั้นยึดตามกิจกรรม ... การเพิ่มวงจรชีวิตอีกอันในกิจกรรมจะดีกว่าในการออกแบบแอปพลิเคชัน ... ฉันหมายถึงโมดูลสถานการณ์การจัดการข้อมูลและการเชื่อมต่อจะได้รับการออกแบบที่ดีขึ้น ทาง ===> นี่คือคำตอบของใครบางคนที่เคยเห็น Android SDK และ …

15 design-patterns  performance  android  fragmentation 

ลองนึกภาพลูกค้าของคุณต้องการที่จะมีความเป็นไปได้ที่จะเพิ่มคุณสมบัติใหม่ (เช่นสี) ให้กับผลิตภัณฑ์ใน eshop ของพวกเขาใน CMS ของพวกเขา แทนที่จะมีคุณสมบัติเป็นฟิลด์: class Car extends Product { protected String type; protected int seats; } คุณอาจจะทำสิ่งที่ชอบ: class Product { protected String productName; protected Map<String, Property> properties; } class Property { protected String name; protected String value; } นั่นคือการสร้างระบบประเภทของตัวเองอยู่ด้านบนของระบบที่มีอยู่ ฉันรู้สึกเช่นนี้อาจเห็นได้ว่าเป็นการสร้างโดเมนเฉพาะหรือไม่? วิธีนี้เป็นรูปแบบการออกแบบที่รู้จักหรือไม่? คุณจะแก้ปัญหาต่างกันหรือไม่? ฉันรู้ว่ามีภาษาที่ฉันสามารถเพิ่มเขตข้อมูลในรันไทม์ แต่สิ่งที่เกี่ยวกับฐานข้อมูล? คุณอยากจะเพิ่ม / …

15 design-patterns  object-oriented 

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

15 git  workflows 

( สำหรับจุดประสงค์ของคำถามนี้เมื่อฉันพูดว่า 'ส่วนต่อประสาน' ฉันหมายถึงโครงสร้างของภาษาinterfaceและไม่ใช่ 'ส่วนต่อประสาน' ในแง่อื่น ๆ ของคำเช่นวิธีสาธารณะที่ชั้นเรียนเสนอโลกภายนอกเพื่อสื่อสารกับและ จัดการมัน. ) การมีเพศสัมพันธ์แบบหลวมสามารถทำได้โดยการมีวัตถุขึ้นอยู่กับสิ่งที่เป็นนามธรรมแทนประเภทคอนกรีต วิธีนี้ช่วยให้การแต่งงานกันแบบหลวม ๆ ด้วยเหตุผลหลักสองประการ: 1-นามธรรมมีแนวโน้มที่จะเปลี่ยนแปลงน้อยกว่าประเภทคอนกรีตซึ่งหมายความว่ารหัสที่ขึ้นต่อกันมีโอกาสน้อยที่จะแตก คอนกรีตที่แตกต่างกัน2ประเภทสามารถใช้งานได้ที่รันไทม์เพราะมันเหมาะสมกับสิ่งที่เป็นนามธรรม คอนกรีตชนิดใหม่สามารถเพิ่มได้ในภายหลังโดยไม่จำเป็นต้องแก้ไขรหัสที่มีอยู่เดิม ตัวอย่างเช่นพิจารณาชั้นCarและสอง subclasses และVolvoMazda หากรหัสของคุณขึ้นอยู่กับ a Carมันสามารถใช้ a Volvoหรือ a Mazdaในระหว่างรันไทม์ ในภายหลังในคลาสย่อยเพิ่มเติมสามารถเพิ่มได้โดยไม่จำเป็นต้องเปลี่ยนรหัสที่ต้องพึ่งพา นอกจากนี้Car- ซึ่งเป็นนามธรรม - มีโอกาสน้อยที่จะมีการเปลี่ยนแปลงกว่าหรือVolvo Mazdaโดยทั่วไปรถยนต์มักจะเหมือนกันมาระยะหนึ่งแล้ว แต่ Volvos และ Mazdas มีแนวโน้มที่จะเปลี่ยนไป I abstractions มีความเสถียรมากกว่าแบบคอนกรีต ทั้งหมดนี้เพื่อแสดงให้เห็นว่าฉันเข้าใจว่าข้อต่อหลวมคืออะไรและจะบรรลุผลได้อย่างไรโดยขึ้นอยู่กับนามธรรมและไม่ใช่ข้อสรุป (ถ้าฉันเขียนบางอย่างไม่ถูกต้องโปรดพูดอย่างนั้น) สิ่งที่ฉันไม่เข้าใจคือ: Abstractions สามารถเป็น superclasses หรืออินเทอร์เฟซ ถ้าเป็นเช่นนั้นเหตุใดอินเทอร์เฟซที่ได้รับการยกย่องโดยเฉพาะสำหรับความสามารถในการยอมให้มีเพศสัมพันธ์แบบหลวม? ฉันไม่เห็นความแตกต่างจากการใช้ซูเปอร์คลาส …

15 design  object-oriented  interfaces 

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

15 licensing  open-source