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

ฉันสับสนเล็กน้อยเกี่ยวกับรูปแบบสถาปัตยกรรมมุมมอง 4 + 1 จับคู่กับ UML Wikipediaให้การแมปต่อไปนี้: มุมมองเชิงตรรกะ:แผนภาพคลาส, แผนภาพการสื่อสาร, แผนภาพลำดับ มุมมองการพัฒนา:แผนภาพส่วนประกอบ, แผนภาพแพคเกจ มุมมองกระบวนการ:แผนภาพกิจกรรม มุมมองทางกายภาพ:แผนภาพการปรับใช้ สถานการณ์จำลอง:แผนภาพการใช้เคส กระดาษบทบาทของ UML แผนภาพลำดับ Constructs ในวัตถุ Lifecycle แนวคิดจะช่วยให้การทำแผนที่ต่อไปนี้: มุมมองเชิงตรรกะ (แผนภาพคลาส (CD), วัตถุแผนภาพ (OD), แผนภาพลำดับ (SD), แผนภาพความร่วมมือ (COD), แผนภาพสถานะของรัฐ (SCD), แผนภาพกิจกรรม (AD)) มุมมองการพัฒนา (แผนภาพแพคเกจแผนภาพส่วนประกอบ) มุมมองกระบวนการ (ใช้แผนภาพกรณี, CD, OD, SD, COD, SCD, AD) มุมมองทางกายภาพ (แผนภาพการปรับใช้) และ ใช้มุมมองกรณี (ใช้แผนภาพกรณี, …

15 architecture  uml  model  view 

ฉันเห็นว่าซอฟต์แวร์บางตัวมีหมายเลขเวอร์ชันเป็นส่วนหนึ่งของชื่อไฟล์ในขณะที่ซอฟต์แวร์อื่นไม่ทำ ฉันคุ้นเคยกับประเภทหลังมากขึ้นและฉันคิดว่ามันเป็นที่นิยมมากกว่า แต่ฉันเห็นประเภทเก่าในห้องสมุดจาวาสคริปต์ ยกตัวอย่างเช่นชื่อไฟล์ jQuery เป็นเหมือนแทนjquery-2.1.0.js jquery.jsเมื่อใดก็ตามที่ฉันอัปเดตไฟล์ประเภทนี้ฉันจะต้องค้นหาสถานที่ในโปรแกรมอื่น ๆ ที่โหลดไฟล์เหล่านี้และเปลี่ยนชื่อไฟล์ที่พวกเขาอ้างถึงและลบเวอร์ชันเก่าของไลบรารีเหล่านี้ด้วยตนเอง ฉันไม่สะดวกดังนั้นฉันค่อนข้างเปลี่ยนชื่อไฟล์เพื่อยกเว้นหมายเลขรุ่นและเก็บชื่อไฟล์ที่อ้างถึงโดยไม่รวมหมายเลขรุ่น ฉันสงสัยว่าตัวเลขเหล่านี้ใช้สำหรับการควบคุมเวอร์ชันบางประเภท แต่ไม่ชัดเจนว่าจะใช้เมื่อใดและอย่างไร ข้อดีและข้อเสียของการรวมหมายเลขรุ่นในชื่อไฟล์คืออะไร มีความเห็นพ้องกันว่าในด้านใดของซอฟต์แวร์หรือภาษาที่ใช้หมายเลขรุ่นในชื่อไฟล์และพื้นที่ / ภาษาใดที่ไม่ได้ใช้? ถ้าเป็นเช่นนั้นมีเหตุผลใดที่

15 version-control  versioning  files 

ฉันกำลังเขียน API ส่วนที่เหลือและสงสัยว่าจะจัดการกับเวอร์ชันต่าง ๆ ได้ดีที่สุดอย่างไร จากนี้ฉันไม่ได้หมายถึงวิธีการกำหนด URI เป็น V2 หรือ V3 แต่วิธีการจัดโครงสร้างรหัสที่กำหนดว่าจะต้อง: รองรับหลายรุ่นในเวลาเดียวกันเช่น URIs V1 & V2 และ V3 ต้องใช้งานพร้อมกัน ฉันจะออก V1 เมื่อพูดว่า V4 เข้ามาเพื่อ จำกัด จำนวนเงินที่สนับสนุนในแต่ละครั้ง หลีกเลี่ยงการทำซ้ำรหัสมากที่สุด ทำให้ง่ายต่อการเพิ่มการเปลี่ยนแปลงที่ไม่ทำลายกับเวอร์ชันโดยไม่ส่งผลกระทบกับเวอร์ชันอื่น ดูเหมือนว่ามีวิธีการบางอย่างที่สามารถทำได้: ใช้ Git เพื่อควบคุมเวอร์ชันโดยมีสาขาสำหรับเวอร์ชันต่าง ๆ (และเวอร์ชันเก่าเป็นหลักโดยที่ไม่มีงานพัฒนาใหม่เกิดขึ้น) นี่หมายความว่าจะไม่มีการทำสำเนารหัสเนื่องจากมีเพียงเวอร์ชันล่าสุดเท่านั้นที่อยู่ในรหัส แต่รุ่นก่อนหน้านี้จะต้องทำงานกับ DB เวอร์ชันใหม่จนกว่าจะถูกยกเลิก ทำซ้ำรหัสเพื่อให้แต่ละรุ่นได้รับการจัดการในแอปพลิเคชันเดียวกันและมีเส้นทางรหัสแยกกันโดยสิ้นเชิง แต่สิ่งนี้จะหมายถึงการทำซ้ำจำนวนมาก ใช้รหัสจำนวนมากซ้ำในเวอร์ชันต่าง ๆ แต่สิ่งนี้จะทำให้ยากต่อการบำรุงรักษาเนื่องจากการเปลี่ยนหนึ่งเวอร์ชันมีแนวโน้มที่จะกระทบกับเวอร์ชันก่อนหน้ามากกว่า มีวิธีปฏิบัติที่ดีที่สุดในการจัดการกับปัญหานี้เนื่องจากตัวเลือกทั้งหมดดูเหมือนจะมีปัญหาของตัวเองหรือไม่?

15 rest  asp.net-mvc-web-api 

ฉันกำลังปรับโครงสร้างคลาสรหัสเดิมอีกครั้ง Refactoring (ฉันเข้าใจ) สนับสนุนสิ่งนี้: เขียนแบบทดสอบสำหรับคลาสดั้งเดิม refactor heck ออกจากชั้นเรียน ปัญหา: เมื่อฉันปรับโครงสร้างห้องเรียนใหม่การทดสอบของฉันในขั้นตอนที่ 1 จะต้องมีการเปลี่ยนแปลง ตัวอย่างเช่นสิ่งที่ครั้งหนึ่งเคยเป็นวิธีดั้งเดิมตอนนี้อาจเป็นชั้นแยกต่างหาก อะไรคือวิธีการหนึ่งที่อาจมีหลายวิธี ภูมิทัศน์ทั้งหมดของชั้นเรียนดั้งเดิมอาจถูกลบล้างเป็นสิ่งใหม่ดังนั้นการทดสอบที่ฉันเขียนในขั้นตอนที่ 1 เกือบจะเป็นโมฆะ ในสาระสำคัญฉันจะเพิ่มขั้นตอนที่ 3 เขียนการทดสอบของฉันอย่างล้นเหลือ อะไรคือจุดประสงค์ในการเขียนแบบทดสอบก่อนที่จะสร้างใหม่? ฟังดูคล้ายกับแบบฝึกหัดทางวิชาการในการสร้างงานให้ตัวเองมากขึ้น ฉันกำลังเขียนแบบทดสอบสำหรับวิธีนี้และฉันกำลังเรียนรู้เพิ่มเติมเกี่ยวกับวิธีทดสอบสิ่งต่าง ๆ และวิธีการทำงานแบบเดิม เราสามารถเรียนรู้สิ่งนี้ได้โดยการอ่านรหัสดั้งเดิม แต่การทดสอบการเขียนนั้นคล้ายกับการถูจมูกของฉันและการบันทึกความรู้ชั่วคราวนี้ในการทดสอบแยกต่างหาก ด้วยวิธีนี้ฉันแทบจะไม่มีทางเลือกนอกจากเรียนรู้ว่าโค้ดทำอะไร ฉันพูดว่าชั่วคราวที่นี่เพราะฉันจะ refactor heck ออกจากรหัสและเอกสารและการทดสอบทั้งหมดของฉันจะเป็นโมฆะและเป็นโมฆะเป็นส่วนสำคัญยกเว้นความรู้ของฉันจะอยู่และอนุญาตให้ฉันสดใน refactoring นั่นคือเหตุผลที่แท้จริงในการเขียนการทดสอบก่อน refactor - เพื่อช่วยให้ฉันเข้าใจรหัสได้ดีขึ้น? จะต้องมีเหตุผลอื่น! กรุณาอธิบาย! บันทึก: มีโพสต์นี้: มันทำให้รู้สึกถึงการเขียนการทดสอบสำหรับรหัสดั้งเดิมเมื่อไม่มีเวลาสำหรับการปรับโครงสร้างที่สมบูรณ์? แต่มันบอกว่า "เขียนการทดสอบก่อน refactor" แต่ไม่ได้พูดว่า "ทำไม" หรือจะทำอย่างไรถ้า "การทดสอบการเขียน" ดูเหมือนว่า …

15 testing  refactoring  tdd  legacy-code 

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

15 programming-practices  refactoring  anti-patterns  regular-expressions  single-responsibility 

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

15 object-oriented  teamwork 

เราต้องการส่งออกข้อมูลบางส่วนจากฐานข้อมูลของเราเป็น XML ยกตัวอย่างเช่นPersonสามารถมีage,nameและบางส่วนคุณสมบัติอื่น ๆ เรามีสองตัวเลือกในการกำหนดรูปแบบ XML ตัวเลือก # 1: <Persons> <Person> <Age>16</Age> <Name>Richard</Name> </Person> <Person> <Age>34</Age> <Name>Eric</Name> </Person> ... </Persons> ตัวเลือก # 2: <Persons> <Person Age="16" Name="Richard"/> <Person Age="34" Name="Eric"/> ... </Persons> ดังนั้นความแตกต่างระหว่างคำจำกัดความของโหนดย่อยหรือคุณลักษณะคืออะไร? และประโยชน์ของแต่ละตัวเลือกคืออะไร

15 xml 

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

15 agile  scrum 

โดเมนความรู้ของเราเกี่ยวข้องกับคนที่เดินข้ามแผ่นบันทึกความกดดันด้วยเท้าเปล่า เราทำการจดจำรูปภาพซึ่งส่งผลให้วัตถุของคลาส 'เท้า' หากเท้ามนุษย์ถูกจดจำในข้อมูลเซ็นเซอร์ มีการคำนวณหลายอย่างที่ต้องดำเนินการกับข้อมูลของเท้า ตอนนี้ API ตัวไหนจะดีกว่า: class Foot : public RecognizedObject { MaxPressureFrame getMaxPressureFrame(); FootAxis getFootAxis(); AnatomicalZones getAnatomicalZones(); // + similar getters for other calculations // ... } หรือ: class Foot : public RecognizedObject { virtual CalculationBase getCalculation(QString aName); // ... } ตอนนี้มีโปรและคอนแสตนท์จำนวนมากที่ฉันสามารถหาได้ แต่ฉันก็ไม่สามารถตัดสินใจได้ว่าอะไรคือสิ่งที่สำคัญที่สุด หมายเหตุนี่เป็นแอปพลิเคชั่นสำหรับผู้ใช้ไม่ใช่ไลบรารี่ซอฟต์แวร์ที่เราขาย คำแนะนำใด ๆ? โปรบางตัวสำหรับวิธีแรกอาจเป็น: …

15 design  c++  object-oriented  programming-practices  language-agnostic 

ฉันโปรแกรมและฉัน dyslexic วิสัยทัศน์ของฉันยอดเยี่ยม ฉันประมวลผลสัญลักษณ์ได้ไม่ดีและฉันเป็นนักคิดเชิงสายตา เมื่อฉันรหัสฉันช้ากว่าคนทั่วไปเพราะฉันไม่รู้ถึงข้อผิดพลาดที่ฉันคาดเดาไม่ได้ ฉันกำลังเรียนรู้หลามและสภาพแวดล้อมการพัฒนาที่เป็นข้อความอย่างเดียวทำให้ฉันมีความเครียดทางสายตามาก ฉันใช้ Wingware ซึ่งค่อนข้างมีประโยชน์ แต่ไม่สามารถทำงานที่ได้รับมอบหมายอย่างสมบูรณ์ในเวลาที่กำหนด คุณช่วยแนะนำที่พักที่จะช่วยฉันได้ไหม การดัดแปลงอะไรจะเป็นประโยชน์กับฉัน มีวิธีใดบ้างที่ฉันสามารถค้นหาเน้นและแก้ไขข้อผิดพลาดประเภทนี้ได้โดยอัตโนมัติ พิสูจน์อักษรฉันเห็นสิ่งที่ฉันคาดหวังที่จะเห็นหรือสิ่งที่คุ้นเคย ฉันไม่ได้สังเกตเห็นความผิดพลาดข้ามบรรทัด ฯลฯ และข้อบกพร่องปรากฏขึ้นในการทดสอบ แม้แต่การคัดลอกและวางฉันสามารถพลาดเส้นและทำให้เกิดข้อผิดพลาด บล็อกข้อความจากระยะขอบถึงขอบทำให้ฉันปวดหัวเช่นเดียวกับการผสมสีบางส่วน ฉันไม่ได้ประมวลผลข้อความเป็นสัญลักษณ์แทนที่จะเป็นวัตถุที่สามารถหมุนได้ transposed เพื่อให้ตัวเลขในการย้ายตัวเลขไปยังสถานที่ต่าง ๆ ฉันอาจรู้สึกว่า "123" เป็น "132" ตัวอักษร "pddq" ดูเหมือนกับ ฉัน. ฉันคิดว่าสิ่งเหล่านี้เป็นเรื่องยุ่งยาก - รูปร่างเดียวกันหมุนและสะท้อน

15 productivity  ide  accessibility 

ฉันเจอคำถามนี้เมื่อสองวินาทีก่อนและฉันดึงเนื้อหาบางส่วนออกจากที่นั่น: มีชื่อของโครงสร้าง 'break n' หรือไม่? สิ่งนี้ดูเหมือนจะเป็นวิธีที่ซับซ้อนอย่างไม่จำเป็นสำหรับคนที่จะต้องสั่งให้โปรแกรมแยกย่อยซ้อนกันสำหรับลูป: for (i = 0; i < 10; i++) { bool broken = false; for (j = 10; j > 0; j--) { if (j == i) { broken = true; break; } } if (broken) break; } ฉันรู้ว่าหนังสือที่ชอบพูดประโยค goto เป็นมารและฉันไม่ชอบมันเลย แต่สิ่งนี้แสดงให้เห็นถึงข้อยกเว้นของกฎหรือไม่? ฉันกำลังมองหาคำตอบที่จัดการกับ n-ซ้อนสำหรับลูป หมายเหตุ:ไม่ว่าคุณจะตอบว่าใช่, …

15 coding-style  goto 

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

15 design  program 

ในตัวเลขมันเป็นสิ่งสำคัญมากที่จะสามารถระบุรูปแบบที่ไม่เสถียรและเพื่อปรับปรุงเสถียรภาพของพวกเขา จะระบุการคำนวณจุดลอยตัวที่ไม่เสถียรได้อย่างไร? ฉันกำลังทำงานกับการจำลองที่ซับซ้อนมากซึ่งมีรูปแบบตัวเลขจำนวนมากทำงานร่วมกันและฉันกำลังมองหาวิธีการระบุส่วนที่อ่อนแอของมัน ฉันกำลังทำงานกับแบบจำลองทางกายภาพที่เกี่ยวข้องกับสมการเชิงอนุพันธ์ มุมมองตานกของกระบวนการโดยรวมคือ: (Preliminary ขั้นตอน) รวบรวมข้อสังเกตทางกายภาพP กำหนดพารามิเตอร์เริ่มต้นของการจำลอง สิ่งนี้ใช้อัลกอริธึมการปรับให้เหมาะสมซึ่งเราเดินเข้าไปในพื้นที่พารามิเตอร์และค้นหาพารามิเตอร์Cเพื่อให้ฟังก์ชั่นข้อผิดพลาดบางอย่างE (F (C), P)ถูกย่อให้เล็กสุดโดยFคือจำนวนพารามิเตอร์ที่ได้รับ เสียบCในเอ็นจิ้นการจำลอง นี่คือโครงร่างออยเลอร์ของ EDP ดังนั้นในแต่ละขั้นตอนเราคำนวณเงื่อนไขที่ขับเคลื่อนไดนามิก (แต่ละอันเป็นฟังก์ชันที่ซับซ้อนอาจมีความไม่แน่นอน) และฟีดออยเลอร์ด้วยเงื่อนไขไดนามิกเหล่านี้เพื่อคำนวณถัดไป สถานะ. สิ่งนี้จะดำเนินต่อไปสำหรับจุดพันเวลา ในตอนท้ายของการจำลองเราคำนวณฟังก์ชั่นProof (S)ของสถานะSสุดท้ายและเปรียบเทียบกับปริมาณที่ต้องการ (P) ซึ่งอนุมานได้จากปริมาณที่สังเกตได้ นี่ไม่ใช่หลักฐานที่เป็นทางการของผลการตรวจสอบความน่าเชื่อถือมากขึ้น นอกจากนี้ฉันยังเห็นหอคอยแห่งการดำเนินงานที่ซับซ้อน (การคำนวณคำศัพท์ไดนามิกภายในโครงการออยเลอร์ภายในหลักฐาน ) และต้องการรับรู้“ ส่วนที่ไม่ดี” และแก้ไขได้ ฉันคาดการณ์ว่าการใช้งานการใช้งานซอฟต์แวร์ของจำนวนจุดลอยตัวที่มีความแม่นยำลดลงจะขยายความไม่แน่นอนของรูปแบบตัวเลขดังนั้นการเปรียบเทียบระหว่างการใช้งานที่แตกต่างกัน นี่เป็นเทคนิคทั่วไปในการตรวจสอบคำถามนี้หรือไม่? เป็นไปได้ไหมที่จะใช้เครื่องเสมือนอย่าง Bochs เพื่อให้ได้สิ่งนี้โดยไม่ต้องเปลี่ยนโปรแกรม? ในการจัดการกับคำถามความมั่นคงอย่างเหมาะสมบางครั้งก็เป็นที่ยอมรับได้ในการกำหนดเป้าหมายอินพุตทั่วไปของกระบวนการเชิงตัวเลขเพื่อให้สามารถปรับได้ดีกับอินพุตนั้นและอาจไม่ค่อยดีกับอินพุตที่ถูกต้อง แต่ไม่น่าเป็นไปได้ ได้รับตัวอย่างของปัจจัยการผลิตโดยทั่วไปก็เป็นไปได้ที่จะสอดแนมผลกลางบางส่วนและเตรียมความพร้อมรายละเอียดทางสถิติสำหรับพวกเขา นี่เป็นเทคนิคทั่วไปในการศึกษาปัญหาด้านความมั่นคงหรือไม่ เครื่องเสมือนมีประโยชน์สำหรับสิ่งนี้หรือไม่?

15 numbers  numeric-precision 

บล็อกคือรายการคำสั่งที่จะดำเนินการ ตัวอย่างของการที่บล็อกเกิดขึ้นใน C อยู่หลังคำสั่ง while และใน if statement while( boolean expression) statement OR block if (boolean expression) statement OR block C ยังอนุญาตให้บล็อกถูกซ้อนในบล็อก ฉันสามารถใช้สิ่งนี้เพื่อนำชื่อตัวแปรมาใช้ใหม่ได้ฉันคิดว่าฉันชอบ 'x' int x = 0; while (x < 10) { { int x = 5; printf("%d",x) } x = x+1; } จะพิมพ์หมายเลข 5 สิบครั้ง ฉันเดาว่าฉันสามารถเห็นสถานการณ์ที่ทำให้จำนวนชื่อตัวแปรต่ำเป็นที่ต้องการ บางทีในการขยายตัวแมโคร อย่างไรก็ตามฉันไม่เห็นเหตุผลที่ยากลำบากที่จะต้องใช้คุณสมบัตินี้ …

15 c  syntax 

ขณะนี้ฉันกำลังสร้างเครื่องมือค้นหาภายในองค์กรขนาดเล็กโดยใช้ Apache Lucene จุดประสงค์ของมันคือเรียบง่าย - จากคำหลักบางคำมันจะแนะนำบทความที่เขียนภายใน บริษัท ของเรา ฉันใช้การให้คะแนน TF-IDF ที่ค่อนข้างเป็นมาตรฐานในฐานะตัวชี้วัดพื้นฐานและสร้างกลไกการให้คะแนนของฉันเองอยู่ด้านบน สิ่งเหล่านี้ดูเหมือนจะทำงานได้อย่างยอดเยี่ยมยกเว้นในบางกรณีที่การจัดอันดับดูยุ่งเหยิง ดังนั้นสิ่งที่ฉันวางแผนจะทำคือการเพิ่มลิงค์ที่เกี่ยวข้อง / ไม่เกี่ยวข้องขนาดเล็กลงในหน้าผลการค้นหาเพื่อให้ผู้ใช้สามารถคลิกที่ลิงค์ใดลิงก์หนึ่งขึ้นอยู่กับการรับรู้ของพวกเขาว่าควรรวมผลลัพธ์นั้นไว้ด้วยหรือไม่ ความคิดของฉัน ปฏิบัติต่อป้ายกำกับที่เกี่ยวข้อง / ไม่เกี่ยวข้องเหล่านี้และสร้างข้อมูลการฝึกอบรม ใช้ข้อมูลนี้เพื่อฝึกฝนลักษณนาม (เช่น SVM) รวมโมเดลนี้ลงในเครื่องมือค้นหาเช่นผลลัพธ์ใหม่ทุกรายการจะผ่านตัวแยกประเภทและจะได้รับการกำหนดป้ายกำกับว่าเกี่ยวข้องหรือไม่ วิธีนี้ดูเหมือนง่ายสำหรับฉัน แต่ฉันไม่แน่ใจว่าจะใช้งานได้จริงหรือไม่ ฉันมีคำถามสองข้อ: คุณสมบัติทั้งหมดที่ฉันควรแยกคืออะไร มีวิธีที่ดีกว่าในการรวมส่วนประกอบการเรียนรู้ของเครื่องเข้ากับเครื่องมือค้นหาหรือไม่ เป้าหมายสุดท้ายของฉันคือ "เรียนรู้" ฟังก์ชั่นการจัดอันดับตามตรรกะทางธุรกิจเช่นเดียวกับความคิดเห็นของผู้ใช้

15 search  language-agnostic  lucene  machine-learning  search-engine