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

คำเตือนใดที่ฉันควรทราบขณะแปลหมายเลขในแอปพลิเคชันส่วนหน้าของฉัน ตัวอย่าง: ในบราซิลโปรตุเกส (pt-BR) เราแบ่งหลายพันด้วยจุดและทศนิยมด้วยเครื่องหมายจุลภาค ในภาษาอังกฤษแบบอเมริกัน (en-US) นั้นตรงกันข้าม ใน pt-BR เราแสดงตัวเลขที่คั่นด้วยหลักพันเหมือนกับ en-US แต่การอ่านเกี่ยวกับภาษาอังกฤษของอินเดีย (en-IN) วันนี้ฉันเจออัญมณีนี้: ระบบหมายเลขอินเดียเหมาะสำหรับการจัดกลุ่มหลัก เมื่อเขียนด้วยคำพูดหรือเมื่อพูดตัวเลขที่น้อยกว่า 100,000 / 100,000 จะแสดงเช่นเดียวกับในภาษาอังกฤษมาตรฐาน ตัวเลขรวมถึงและเกิน 100,000 / 100,000 แสดงเป็นส่วนย่อยของระบบเลขอินเดีย https://en.wikipedia.org/wiki/Indian_English#Numbering_system ซึ่งหมายความว่า: 1000000 units in pt-BR are formatted 1.000.000 1000000 units in en-US are formatted 1,000,000 1000000 units in en-IN are formatted 10,00,000 นอกเหนือจากเครื่องหมายจุลภาคและจุดและตัวคั่นเฉพาะอื่น …

38 internationalization  localization  culture  information-presentation 

ฉันมีโครงการตัวช่วยซึ่งฉันใช้ในแอปพลิเคชันทั้งหมดที่ฉันสร้าง มันมีวิธีการขยายและเรียนผู้ช่วยทั่วไปการควบคุม ฯลฯ ฉันอัปเดต / ขยายโครงการผู้ช่วยเป็นครั้งคราว เหล่านี้มักเป็นโครงการขนาดเล็กและไม่เกี่ยวข้องและฉันเป็นคนเดียวที่ทำงานกับพวกเขาทั้งหมด ฉันลองสองวิธีในการใช้ เพิ่มไฟล์. cs โดยตรง (เพิ่มลิงค์) ไปยังแต่ละโครงการที่ฉันใช้ รวบรวมเป็น. dll และเพิ่มเป็นข้อมูลอ้างอิง ฉันเห็นประโยชน์และข้อเสียของวิธีการเหล่านี้ คนแรก: นั้นง่ายกว่าเนื่องจากคลาสตัวช่วยได้รับการคอมไพล์เป็นไฟล์ exe ดังนั้นฉันมักจะสามารถให้ไฟล์. exe เพียงไฟล์เดียวที่ใช้งานได้ดี เนื่องจากฉันเพิ่มเป็นลิงก์ฉันจึงมั่นใจได้ว่าเมื่อใดก็ตามที่ฉันสร้างโครงการใด ๆ ที่ใช้ตัวช่วยเหลือไฟล์ผู้ช่วยเหลือจะเป็นเวอร์ชันล่าสุด ยิ่งง่ายขึ้นเพราะฉันสามารถแยกไฟล์เพื่อให้วิธีการขยายของฉันที่ทำงานได้ดีบน. NET 4.0 สามารถอ้างอิงแยกต่างหากจากวิธีที่ต้องใช้. NET 4.5 ซึ่งหมายความว่าแอปโดยรวมสามารถทำงานบน. NET 4.0 ได้ ช่วยให้การแก้จุดบกพร่องผ่านรหัสที่มีประโยชน์ทั้งหมดของเบรกพอยต์ ฯลฯ ฯลฯ ... ดูเหมือนจะไม่ใช่ 'การปฏิบัติที่ดีที่สุด' คนที่สอง: ดูเหมือนจะเป็นแนวทางที่ถูกต้อง แต่: ต้องการให้ฉันส่งไฟล์. dll แยกต่างหากซึ่งด้วยเหตุผลบางอย่างยากกว่าสำหรับผู้ใช้ (พวกเขามักจะแบ่งปันโปรแกรมของฉันโดยไม่ใช้. dll …

38 c#  dll 

ก่อนหน้านี้ฉันใช้ภาษาเขียนโปรแกรมเชิงวัตถุเท่านั้น (C ++, Ruby, Python, PHP) และตอนนี้ฉันเรียนรู้ C. ฉันพบว่ามันยากที่จะหาวิธีที่เหมาะสมในการทำสิ่งต่าง ๆ ในภาษาโดยไม่มีแนวคิดเรื่อง 'วัตถุ'. ฉันรู้ว่ามันเป็นไปได้ที่จะใช้กระบวนทัศน์ OOP ใน C แต่ฉันต้องการเรียนรู้วิธีการ C - สำนวน เมื่อแก้ปัญหาการเขียนโปรแกรมสิ่งแรกที่ฉันทำคือการจินตนาการวัตถุที่จะแก้ปัญหา ฉันจะแทนที่ขั้นตอนใดได้บ้างเมื่อใช้กระบวนทัศน์การเขียนโปรแกรมที่ไม่ใช่ OOP Imperative

38 object-oriented  c 

ถ้าฉันต้องการที่จะบันทึกและดึงวัตถุฉันควรสร้างคลาสอื่นเพื่อจัดการกับมันหรือมันจะดีกว่าที่จะทำในชั้นเรียนของตัวเอง? หรืออาจจะผสมทั้งสองอย่าง? ข้อเสนอแนะใดบ้างตามกระบวนทัศน์ของ OOD ตัวอย่างเช่น Class Student { public string Name {set; get;} .... public bool Save() { SqlConnection con = ... // Save the class in the db } public bool Retrieve() { // search the db for the student and fill the attributes } public List<Student> RetrieveAllStudents() { …

38 design  object-oriented 

ฉันพยายามที่จะเข้าใจการจำแนกประเภทเหล่านี้และสาเหตุที่มีอยู่ ความเข้าใจของฉันถูกต้องหรือไม่ ถ้าไม่อะไร P คือความซับซ้อนของพหุนามหรือสำหรับจำนวนจริงที่ไม่เป็นลบเช่นฯลฯ หากปัญหาเป็นของ P ดังนั้นจะมีอัลกอริทึมอย่างน้อยหนึ่งตัวที่สามารถแก้ไขได้ตั้งแต่เริ่มต้นในเวลาพหุนาม ตัวอย่างเช่นฉันมักจะสามารถคิดออกถ้าจำนวนเต็มบางส่วนเป็นสำคัญโดยการวนลูปและการตรวจสอบในแต่ละขั้นตอนถ้าแบ่งO(nk)kO(1), O(n1/2), O(n2), O(n3)n2 <= k <= sqrt(n)kn NP เป็นความซับซ้อนของพหุนามที่ไม่สามารถกำหนดได้ ฉันไม่รู้จริง ๆ ว่าการไม่เป็นตัวกำหนดความหมายคืออะไร ฉันคิดว่ามันง่ายต่อการตรวจสอบในเวลาพหุนาม แต่อาจหรืออาจไม่ใช่เวลาพหุนามที่จะแก้ไขตั้งแต่ต้นหากเราไม่ทราบคำตอบ เนื่องจากอาจแก้ไขได้ในเวลาพหุนามปัญหา P ทั้งหมดจึงเป็นปัญหา NP การแยกตัวประกอบจำนวนเต็มได้รับการยกมาเป็นตัวอย่างของ NP แต่ฉันไม่เข้าใจว่าทำไมมันไม่ใช่ P ส่วนตัวเนื่องจากการแยกตัวประกอบการทดลองใช้O(sqrt(n))เวลา NP-Complete ฉันไม่เข้าใจเลย แต่ปัญหาของพนักงานขายที่เดินทางถูกยกมาเป็นตัวอย่างของสิ่งนี้ แต่ในความเห็นของฉันปัญหาของ TSP อาจเป็น NP เพราะมันต้องมีการตรวจสอบว่าคุณได้รับเส้นทางล่วงหน้าหรือไม่O(2n n2) time to solve, but O(n) NP-Hard ฉันคิดว่าเต็มไปด้วยสิ่งแปลกปลอม ยากที่จะตรวจสอบและยากที่จะแก้ไข

38 complexity  big-o  definition  np-complete 

นี่เป็นสิ่งที่ทำให้ฉันหนักใจอยู่พักหนึ่งแล้ว จริง ๆ แล้วมันคุ้มค่ากับการทดสอบหน่วยลูกค้า API หรือไม่ สมมติว่าคุณกำลังสร้างชั้นเรียนขนาดเล็กเพื่อสรุปการโทรหาสัตว์เลี้ยง REST API Petshop เป็น API ที่ง่ายมากและมีชุดวิธีพื้นฐาน: listProducts() getProductDetails(ProductID) addProduct(...) removeProduct(ProductID) ในการทดสอบสิ่งนี้เราต้องสร้างบริการจำลองหรือตอบกลับ แต่นั่นดูเหมือน overkill; ฉันเข้าใจว่าเราต้องการตรวจสอบให้แน่ใจว่าวิธีการของเราไม่หยุดทำงานผ่านข้อผิดพลาดของ typo / syntax แต่เนื่องจากเรากำลังเขียนฟังก์ชั่นที่เรียกใช้วิธีการทางไกลแล้วเรากำลังสร้างการตอบกลับปลอมจากวิธีการทางไกลเหล่านั้น เป็นการเสียความพยายามและเรากำลังทดสอบบางสิ่งที่ไม่สามารถล้มเหลวได้จริงๆ ที่แย่กว่านั้นหากวิธีการระยะไกลเปลี่ยนการทดสอบหน่วยของเราจะผ่านในขณะที่การใช้การผลิตล้มเหลว ฉันค่อนข้างมั่นใจว่าฉันพลาดอะไรบางอย่างไปหรือฉันมีไม้ผิดหรือฉันไม่ได้เห็นต้นไม้สำหรับต้นไม้ มีคนตั้งฉันให้ถูกทางได้ไหม?

38 unit-testing  api 

ฉันกำลังค้นคว้าเกี่ยวกับชุดคอมไพเลอร์ gcc ในวิกิพีเดียที่นี่เมื่อสิ่งนี้เกิดขึ้น: GCC เริ่มต้นใช้ตัวแยกวิเคราะห์ LALR ที่สร้างด้วย Bison แต่ค่อย ๆ เปลี่ยนเป็นตัวแยกวิเคราะห์แบบสืบเชื้อสายแบบเขียนด้วยมือซ้ำ; สำหรับ C ++ ในปี 2004 และสำหรับ C และ Objective-C ในปี 2549 ปัจจุบันส่วนหน้าทั้งหมดใช้ตัวแยกวิเคราะห์ที่เขียนด้วยมือแบบเรียกซ้ำ ดังนั้นด้วยประโยคสุดท้ายนั้น (และสำหรับที่ฉันไว้ใจ wikipedia) ฉันสามารถพูดได้อย่างแน่นอนว่า "C (gcc), C ++ (g ++), Objective-C, Objective-C ++, Fortran (gfortran), Java (gcj), Ada (GNAT), Go (gccgo), Pascal (gpc), ... Mercury, Modula-2, Modula-3, …

38 java  ruby  haskell  parsing  swift-language 

ฉันได้เห็นว่าในกระบวนทัศน์ที่จำเป็น f (x) + f (x) อาจไม่เหมือนกับ: 2 * f (x) แต่ในกระบวนทัศน์การทำงานมันควรจะเหมือนกัน ฉันได้ลองใช้ทั้งสองกรณีใน Python และSchemeแต่สำหรับฉันแล้วพวกเขาดูตรงไปตรงมาเหมือนกัน อะไรคือตัวอย่างที่สามารถชี้ให้เห็นความแตกต่างกับฟังก์ชั่นที่ให้

38 functional-programming  imperative-programming 

แอปพลิเคชันสามารถโยนข้อผิดพลาดได้เสมอ หากมีข้อผิดพลาดเกิดขึ้นผู้ใช้ควรได้รับการแจ้งเตือนเพราะสิ่งที่เขาขอให้แอปพลิเคชันทำไม่สำเร็จ อย่างไรก็ตามผู้ใช้ควรได้รับข้อมูลเท่าไหร่? ฉันคิดว่าพวกเราส่วนใหญ่เห็นด้วยที่จะไม่แสดงการติดตามสแต็ก ( ควรติดตามสแต็กในข้อความแสดงข้อผิดพลาดที่ปรากฏแก่ผู้ใช้หรือไม่ ) แต่ฉันไม่พบคำถามเกี่ยวกับเนื้อหาข้อผิดพลาดที่เหลือหรือสิ่งที่จะแสดงต่อ ผู้ใช้งาน ตัวอย่างเช่นภาษาที่รองรับข้อยกเว้น (.net, java) มีประเภทข้อยกเว้นที่จะแบ่งปันโดยที่ข้อยกเว้นเกิดขึ้นและข้อความที่ค่อนข้างชัดเจนเพื่อให้สอดคล้องกับข้อยกเว้น สิ่งนี้ควรถูกซ่อนจากผู้ใช้ด้วยหรือไม่ หรือเราควรแสดงสิ่งนี้ต่อไป? หรือเราควรแสดงข้อความทั่วไป? หรือเราควรแสดงหนึ่งในจำนวนข้อความตามข้อยกเว้นพื้นฐานคืออะไร

38 user-interface  error-handling  user-experience  error-messages  information-presentation 

จนถึงตอนนี้ฉันไม่ทราบความแตกต่างที่สำคัญระหว่างทั้งสามนี้ เมื่อมีคนถามฉันเกี่ยวกับเรื่องนี้ฉันจะบอกพวกเขาว่า C # เป็นภาษาการเขียนโปรแกรม HTML และ XML เป็นภาษามาร์กอัปและ JavaScript และ VBScript เป็นภาษาสคริปต์ แต่อะไรคือความแตกต่างที่สำคัญที่ทำให้พวกเขาแตกต่างจากคนอื่น?

38 programming-languages  terminology  scripting  markup 

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

38 coding-style  html  clean-code 

ฉันพบข้อความนี้ใน " ความสุขของ Clojure " บนหน้า 32 แต่มีบางคนพูดสิ่งเดียวกันกับฉันในมื้อค่ำเมื่อสัปดาห์ที่แล้วและฉันก็ได้ยินที่อื่นเช่นกัน: [A] ข้อเสียของการเขียนโปรแกรมเชิงวัตถุคือการมีเพศสัมพันธ์อย่างแน่นหนาระหว่างฟังก์ชั่นและข้อมูล ฉันเข้าใจว่าเหตุใดการเชื่อมต่อที่ไม่จำเป็นจึงไม่ดีในแอปพลิเคชัน นอกจากนี้ฉันรู้สึกสบายใจที่จะบอกว่าควรหลีกเลี่ยงสถานะและการสืบทอดที่ไม่แน่นอนแม้ในการเขียนโปรแกรมเชิงวัตถุ แต่ฉันล้มเหลวที่จะเห็นว่าทำไมการติดฟังก์ชั่นในชั้นเรียนจึงไม่ดีอย่างแท้จริง ฉันหมายถึงการเพิ่มฟังก์ชั่นในชั้นเรียนดูเหมือนว่าจะติดแท็กเมลใน Gmail หรือติดไฟล์ในโฟลเดอร์ เป็นเทคนิคขององค์กรที่ช่วยให้คุณค้นพบอีกครั้ง คุณเลือกเกณฑ์บางอย่างจากนั้นรวบรวมสิ่งต่าง ๆ เข้าด้วยกัน ก่อน OOP โปรแกรมของเรามีวิธีการมากมายในไฟล์ ฉันหมายความว่าคุณต้องใส่ฟังก์ชั่นบางแห่ง ทำไมไม่จัดระเบียบพวกเขา? หากนี่เป็นการโจมตีแบบ veiled ในประเภททำไมพวกเขาถึงไม่พูดว่าการ จำกัด ประเภทของอินพุตและเอาต์พุตไปยังฟังก์ชันนั้นผิด ฉันไม่แน่ใจว่าฉันจะเห็นด้วยกับเรื่องนี้หรือไม่ แต่อย่างน้อยฉันก็คุ้นเคยกับข้อโต้แย้งอย่างมืออาชีพและความปลอดภัยในการพิมพ์ ฟังดูเป็นเรื่องที่ฉันกังวลเป็นส่วนใหญ่ แน่นอนว่าบางครั้งผู้คนเข้าใจผิดและวางการทำงานผิดประเภท แต่เมื่อเทียบกับข้อผิดพลาดอื่น ๆ ดูเหมือนว่าจะเป็นความไม่สะดวกเล็กน้อย ดังนั้น Clojure มีเนมสเปซ การผสานฟังก์ชันกับคลาสใน OOP แตกต่างจากการผสานฟังก์ชันในเนมสเปซใน Clojure ได้อย่างไรและทำไมมันจึงไม่ดี โปรดจำไว้ว่าฟังก์ชั่นในชั้นเรียนไม่จำเป็นต้องทำงานกับสมาชิกของคลาสนั้นเสมอไป ดูที่ java.lang.StringBuilder - ทำงานกับประเภทการอ้างอิงใด …

38 object-oriented  functions  clojure  namespace  coupling 

เมื่อเร็ว ๆ นี้ผมมาในจำนวนของโอเพนซอร์สทับทิม (หรือส่วนใหญ่ของมันเป็นทับทิม) โครงการบน GitHubว่าเมื่อตรวจสอบด้วยเครื่องมือวิเคราะห์รหัสเช่นRubocopสร้างจำนวนมากของการกระทำผิด ตอนนี้ความผิดส่วนใหญ่เหล่านี้รวมถึงการใช้เครื่องหมายอัญประกาศคู่แทนการอ้างอิงเดี่ยว (เมื่อไม่มีการแก้ไข) ไม่ปฏิบัติตามกฎ 2 ช่องว่างต่อกฎระดับมากกว่ากฎความยาวบรรทัด 80 อักขระหรือใช้{และ}สำหรับบล็อกหลายบรรทัด [คู่มือ] Ruby style แนะนำวิธีปฏิบัติที่ดีที่สุดเพื่อให้โปรแกรมเมอร์ Ruby ในโลกแห่งความจริงสามารถเขียนโค้ดที่สามารถดูแลได้โดยโปรแกรมเมอร์ Ruby จากโลกแห่งความเป็นจริง ~ ที่มา: คู่มือสไตล์ทับทิม แม้ว่าจะมีขนาดเล็กและง่ายต่อการแก้ไขมันเหมาะสมหรือไม่ที่จะเปลี่ยนรูปแบบการเข้ารหัสของโครงการโอเพ่นซอร์สโดยการแก้ไขความผิดและทำการร้องขอแบบดึง ฉันยอมรับว่าบางโครงการเช่น Rails ไม่ยอมรับการเปลี่ยนแปลงเครื่องสำอางและบางอันก็ใหญ่เกินกว่าที่จะ "แก้ไข" ทั้งหมดในครั้งเดียว (ตัวอย่างเช่น Rails สร้างความผิดมากกว่า 80,000 ครั้งเมื่อ Rubocop ทำงาน - ไม่ว่าพวกเขาจะมีการเข้ารหัสขนาดเล็กอนุสัญญาที่ควรปฏิบัติตามเมื่อมีส่วนร่วม) ท้ายที่สุดแล้วRuby Style Guideมีเหตุผลร่วมกับเครื่องมือเช่น Rubocop ผู้คนชื่นชมความสอดคล้องดังนั้นการเปลี่ยนแปลงประเภทนี้เป็นการทำสิ่งที่ดีสำหรับชุมชน Ruby โดยทั่วไปใช่ไหม [ผู้แต่งคู่มือ Ruby Style] ไม่ได้เกิดขึ้นกับกฎทั้งหมด …

38 open-source  coding-style  ruby 

ฉันชอบการจัดการหน่วยความจำตามขอบเขต (SBMM) หรือRAIIจริงๆแล้วเนื่องจากชุมชน C ++ เป็นที่รู้จักกันมากกว่าปกติ เท่าที่ฉันรู้ยกเว้น C ++ (และ C) ไม่มีภาษากระแสหลักอื่น ๆ ที่ใช้อยู่ในปัจจุบันซึ่งทำให้ SBMM / RAII เป็นกลไกการจัดการหน่วยความจำหลักและแทนที่จะต้องการใช้การรวบรวมขยะ (GC) ฉันพบว่ามันค่อนข้างสับสนตั้งแต่ SBMM ทำให้โปรแกรมกำหนดค่าได้มากขึ้น (คุณสามารถบอกได้อย่างแม่นยำเมื่อวัตถุถูกทำลาย) ในภาษาที่ใช้ GC คุณมักจะต้องทำการจัดการทรัพยากรด้วยตนเอง (ดูที่การปิดไฟล์ใน Java เช่น) ซึ่งบางส่วนเอาชนะวัตถุประสงค์ของ GC และยังมีข้อผิดพลาดเกิดขึ้นได้ง่าย หน่วยความจำฮีปสามารถ (ขอบเขตอย่างสวยงามมาก, imo) ได้เช่นกัน (ดูstd::shared_ptrใน C ++) ทำไม SBMM ถึงไม่ใช้กันอย่างแพร่หลาย? ข้อเสียของมันคืออะไร?

38 c++  programming-languages  language-design  garbage-collection  raii 

ในหลายภาษาเช่น C, C ++ และ Java ที่mainวิธีการ / ฟังก์ชั่นมีประเภทการกลับมาของvoidหรือintแต่ไม่ได้หรือdouble Stringอะไรคือเหตุผลเบื้องหลัง ฉันรู้ว่านิด ๆ หน่อย ๆ ว่าเราไม่สามารถทำเช่นนั้นเพราะmainถูกเรียกโดยห้องสมุดรันไทม์และคาดว่าไวยากรณ์บางอย่างเช่นint main()หรือint main(int,char**)ดังนั้นเราจึงต้องติดว่า ดังนั้นคำถามของฉันคือ: ทำไมmainมีลายเซ็นประเภทที่มีและไม่แตกต่างกันอย่างไร

38 programming-languages  history