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

ฉันพบว่ามันน่าหงุดหงิดที่ความเร็วของการพัฒนาที่ภาษาแบบไดนามิกควรให้ได้รับนั้นลดลงอย่างมากจากการขาดความสมบูรณ์และทรัพย์สินอื่น ๆ ที่ IDEs จะมอบให้คุณในรูปแบบคงที่ มันไม่เพียงเกี่ยวกับการพิมพ์น้อยลงเท่านั้น แต่ยังเพิ่มประสิทธิภาพการทำงานและความสนุกที่คุณได้รับจากการเรียกดู API โดยไม่จำเป็นต้องอ้างถึงเอกสารที่ไม่ได้รวมเข้ากับเครื่องมือแก้ไข ในวันที่ชุดภาษา IDE + แบบไดนามิกทั้งหมด - ซึ่งเป็นงานที่ไม่มาก - ฉันได้ลองแล้ว: รถม้าชนิดเล็ก ช้า clueless / overenthusiastic (ในการแสดงความสำเร็จทั้งหมดที่เป็นไปได้) หรือไม่สมบูรณ์เท่ากับพูด Eclipse + Java ฉันทราบว่าการวิเคราะห์โค้ดแบบไดนามิกไม่ใช่เรื่องง่าย แต่มีใครไม่สามารถช่วยสงสัย - เป็นรหัสชิ้นนี้ยากที่จะคิดออก ? ดังนั้นคำถามของฉันคือ: มี IDEs ใด ๆ (หรือน้อยกว่าการตั้งค่า all-in-one) ได้รับการสนับสนุนที่ยอดเยี่ยมสำหรับภาษาแบบไดนามิกหรือไม่หรือนี่ยังคงเป็นปัญหา

56 ide  dynamic-languages 

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

56 agile  development-process  scrum 

ขณะนี้เรากำลังจ้างนักพัฒนารุ่นใหม่เพื่อช่วยเหลือฉันเนื่องจากฉันมีโครงการมากกว่าที่ฉันสามารถจัดการได้ในขณะนี้ ฉันไม่เคยจ้างใครที่ไม่ใช่เพื่อนหรือคนรู้จักอย่างน้อยที่สุด ฉันมีการสัมภาษณ์ทางโทรศัพท์กับผู้สมัครคนเดียวที่โดดเด่นสำหรับฉันจริงๆ (บนกระดาษ) แต่ฉันไม่เคยทำแบบนี้มาก่อน โครงการของเรานั้นมีความยืดหยุ่นในการใช้งานสูงเว็บแอปพลิเคชั่นที่ใช้ข้อมูลจำนวนมากซึ่งประมวลผลการทำธุรกรรมหลายล้านครั้งต่อชั่วโมงทั่วทั้งเซิร์ฟเวอร์และไคลเอนต์ เพื่อให้เป็นภาษา / สแต็คที่เฉพาะเจาะจงเราใช้ ASP.Net MVC2, WebForms และ C # 4, MSSQL 2008 R2 ซึ่งทั้งหมดทำงานบน Windows Server 2008 R2 ฉันควรถามเขาอย่างไร ฉันควรจัดโครงสร้างการโทรอย่างไร

56 interview  hiring  junior-programmer 

จนถึงตอนนี้ฉันได้ยินเกี่ยวกับ: แลมบ์ดาแคลคูลัส การเขียนโปรแกรมแลมบ์ดา นิพจน์แลมบ์ดา ฟังก์ชั่นแลมบ์ดา ซึ่งดูเหมือนว่าทั้งหมดจะเกี่ยวข้องกับการเขียนโปรแกรมการทำงาน ... เห็นได้ชัดว่ามันจะถูกรวมเข้ากับ C ++ 1x ดังนั้นฉันอาจเข้าใจได้ดีขึ้นในตอนนี้: http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions ใครบางคนสามารถกำหนดสิ่ง lambdas สิ่งสั้น ๆ และให้ที่มันจะมีประโยชน์?

56 c++  functional-programming  lambda 

ในขณะที่ฉันมีปัญหา debugged ใน com, เคียงข้างกันจัดการกับ dll นรกทั้งหมดในขณะที่เกลียดรีจิสทรีของ Windows ด้วยความหลงใหลฉันสงสัยว่าทำไมมันจำเป็น ฉันไม่เคยรู้สึกว่าถูกบังคับให้อ่านหนังสือทั้งเล่มเกี่ยวกับแนวปฏิบัติที่ดีที่สุดในการลงทะเบียนสตรีจากนั้นเพียงแค่ "รับมัน" อย่างไรก็ตามฉันใช้ Linux และ Mac OS และดูวิธีที่หนึ่งสามารถติดตั้ง Python และไลบรารี่หลายเวอร์ชันบนคอมพิวเตอร์เครื่องเดียวกัน * เนื่องจากรีจิสทรีมีรูปแบบฟรี (แม้ว่าจะน่าเกลียด) และใช้สำหรับวัตถุประสงค์ทุกประเภทฉันไม่เคยเข้าใจปัญหาที่สำคัญที่พยายามแก้ไข ตัวอย่างเช่น Microsoft ไม่ต้องการให้คุณติดตั้ง MS Office สองรุ่นที่แตกต่างกัน พวกเขาใช้รีจิสทรีเพื่อบังคับใช้ในระหว่างการติดตั้ง ข้อ จำกัด นี้เป็นของเทียมในความคิดของฉัน หากพวกเขาสนใจที่จะยอมให้มีพฤติกรรมที่แตกต่างกันพวกเขาก็สามารถปรับสถาปัตยกรรมให้สอดคล้องได้ ใน Mac OS คุณสามารถติดตั้งและลบแอพได้โดยวางลงในโฟลเดอร์เฉพาะ ดังนั้น, A) ปัญหาสำคัญที่พยายามแก้ไขคืออะไร B) ระบบปฏิบัติการอื่นแก้ปัญหาได้อย่างไร?

56 windows-registry 

บนหน้าจอไวด์สกรีนสามารถดูได้ครั้งละ 80 ตัวอักษรโดยไม่ต้องใช้แถบเลื่อน แม้ Linus Torvalds เห็นขีด จำกัด 80 ตัวอักษรเป็นล้าสมัย ดังนั้นขีด จำกัด 80 อักขระยังคงเกี่ยวข้องในช่วงเวลาของจอภาพแบบจอกว้างหรือไม่

56 coding-style 

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

56 productivity  code-quality  object-oriented  code-reuse 

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

56 self-improvement  books 

วิธีการอ้างอิงข้ามค่าใช้จ่ายของเสื้อคลุมแลมบ์ดา? พวกเขาอาจจะในอนาคตหรือไม่ อ้างอิงจากการสอนของ Java เกี่ยวกับวิธีการอ้างอิง : บางครั้ง ... การแสดงออกแลมบ์ดาไม่ทำอะไรเลยนอกจากเรียกวิธีการที่มีอยู่ ในกรณีเหล่านั้นมักจะชัดเจนกว่าในการอ้างอิงถึงวิธีการที่มีอยู่ตามชื่อ การอ้างอิงวิธีใช้ทำให้คุณสามารถทำได้ มันเป็นแลมบ์ดาขนาดกะทัดรัดและอ่านง่ายสำหรับวิธีการที่มีชื่ออยู่แล้ว ฉันชอบไวยากรณ์แลมบ์ดากับไวยากรณ์การอ้างอิงเมธอดด้วยเหตุผลหลายประการ: แลมบ์ดานั้นชัดเจนขึ้น แม้จะมีการอ้างสิทธิ์ของออราเคิล แต่ฉันพบว่าแลมบ์ดาไวยากรณ์นั้นง่ายต่อการอ่านมากกว่าการอ้างอิงวิธีการออบเจ็กต์สั้น ๆ เพราะไวยากรณ์การอ้างอิงเมธอดนั้นไม่ชัดเจน: Bar::foo คุณกำลังเรียกวิธีการหนึ่งอาร์กิวเมนต์คงที่ในชั้นเรียนของ x และผ่านมันได้หรือไม่ x -> Bar.foo(x) หรือคุณกำลังเรียกวิธีการเป็นศูนย์อาร์กิวเมนต์บน x? x -> x.foo() ไวยากรณ์การอ้างอิงเมธอดสามารถยืนอยู่ได้ทั้งอันใดอันหนึ่ง มันซ่อนสิ่งที่รหัสของคุณกำลังทำอยู่ แลมบ์ดาปลอดภัยกว่า หากคุณอ้างอิง Bar :: foo เป็นวิธีการเรียนและ Bar ภายหลังเพิ่มวิธีการตัวอย่างที่มีชื่อเดียวกัน (หรือในทางกลับกัน) รหัสของคุณจะไม่รวบรวมอีกต่อไป คุณสามารถใช้ lambdas อย่างสม่ำเสมอ คุณสามารถห่อฟังก์ชั่นใด ๆ ในแลมบ์ดา - เพื่อให้คุณสามารถใช้ไวยากรณ์เดียวกันได้ทุกที่ …

56 java  performance  syntax  lambda  java8 

เป็นการบีบอัดอย่างง่ายที่คุณใช้ตัวแปรตัวเลขหนึ่งตัวเพื่อเก็บสถานะบูลีน / ไบนารีจำนวนมากโดยใช้การเสแสร้งและความจริงที่ว่าทุกการเพิ่มทวีคูณเป็น 1 + ผลรวมของก่อนหน้านี้ทั้งหมด ฉันแน่ใจว่ามันต้องเป็นเทคนิคที่เก่าแก่และเป็นที่รู้จักกันดี ผมได้ดำเนินการค้นหาหลายวิธีที่ฉันสามารถคิดที่จะอธิบายมันทุกครั้ง แต่พบว่าไม่มีอะไรเกินกว่าบางบทความบล็อกที่เขียนบทความดูเหมือนจะได้คิดว่าตัวเองนี้และไม่ทราบว่าจะเรียกมันว่าอย่างใดอย่างหนึ่ง ( เช่น 1 , ตัวอย่างที่ 2 ) ตัวอย่างเช่นนี่เป็นการใช้งานที่ง่ายมากซึ่งมีจุดประสงค์เพื่อแสดงแนวคิด: packStatesIntoNumber () { let num = 0 if (this.stateA) num += 1 if (this.stateB) num += 2 if (this.stateC) num += 4 if (this.stateD) num += 8 if (this.stateE) num += 16 if …

55 terminology  bit 

ฉันเพิ่งปรับปรุงรหัสบางส่วนในที่ทำงานเมื่อเร็ว ๆ นี้และฉันคิดว่าฉันทำงานได้ดี ฉันลดโค้ด 980 บรรทัดไปที่ 450 และลดจำนวนคลาสลงครึ่งหนึ่ง เมื่อแสดงสิ่งนี้ต่อเพื่อนร่วมงานของฉันบางคนไม่เห็นด้วยว่านี่เป็นการปรับปรุง พวกเขากล่าวว่า - "บรรทัดที่น้อยกว่าของรหัสไม่จำเป็นต้องดีกว่า" ฉันสามารถเห็นได้ว่าอาจมีกรณีร้ายแรงที่ผู้คนเขียนเส้นยาวจริง ๆ และ / หรือใส่ทุกอย่างในวิธีการเดียวเพื่อบันทึกสองสามบรรทัด แต่นั่นไม่ใช่สิ่งที่ฉันทำ รหัสในความคิดของฉันมีโครงสร้างที่ดีและง่ายต่อการเข้าใจ / บำรุงรักษาเนื่องจากมันมีขนาดเพียงครึ่งเดียว ฉันกำลังดิ้นรนเพื่อดูว่าทำไมทุกคนต้องการทำงานกับรหัสสองเท่าที่จำเป็นสำหรับการทำงานให้เสร็จและฉันสงสัยว่าถ้าใครรู้สึกเหมือนเพื่อนร่วมงานของฉันและสามารถสร้างกรณีที่ดีสำหรับการมีรหัสมากกว่า ?

55 design  coding-style  code-quality 

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

55 productivity  metrics 

ฉันวางแผนที่จะออกแบบและตั้งค่าฐานข้อมูลเพื่อจัดเก็บรายการพจนานุกรม (มักเป็นคำเดียว) และความหมายของพวกเขาในภาษาอื่น ตัวอย่างเช่นตารางอภิธานศัพท์จะต้องมีรายการและคำนิยามและแต่ละระเบียนในตารางมีการอ้างอิงถึงidของบันทึกที่เก็บไว้ในTag(แต่ละรายการจะต้องมีแท็กหรือหมวดหมู่) เนื่องจากข้อมูลของฉันมีโครงสร้างฉันคิดว่าการใช้ฐานข้อมูล SQL (เช่น MySQL) ไม่ใช่ความคิดที่แย่ แต่ผู้คนบอกว่า MongoDB นั้นดีกว่ามากสำหรับประสิทธิภาพ ที่ฝั่งไคลเอ็นต์แอปพลิเคชันจะต้องสามารถให้ช่องค้นหาด้วยการเติมข้อความอัตโนมัติซึ่งใช้ REST API ที่แบ็กเอนด์จัดหาให้ ปลอดภัยที่จะไปกับ MySQL ในสถานการณ์เช่นนี้หรือไม่? หรือฉันควรใช้ MongoDB หรือ ElasticSearch ของการแก้ปัญหาอื่น ๆ สำหรับเรื่องนี้? ควรมีการจัดเก็บและเข้าถึงบันทึกหลายแสนรายการด้วยวิธีนี้

55 database-design  data-structures  mysql  relational-database  mongodb 

ฉันมักจะพบปัญหานี้โดยเฉพาะใน Java แม้ว่าฉันคิดว่ามันเป็นปัญหา OOP ทั่วไป นั่นคือการเพิ่มข้อยกเว้นพบปัญหาการออกแบบ สมมติว่าฉันมีคลาสที่มีString nameฟิลด์และString surnameฟิลด์ จากนั้นจะใช้ฟิลด์เหล่านั้นเพื่อเขียนชื่อเต็มของบุคคลเพื่อแสดงในเอกสารบางประเภทพูดใบแจ้งหนี้ public void String name; public void String surname; public String getCompleteName() {return name + " " + surname;} public void displayCompleteNameOnInvoice() { String completeName = getCompleteName(); //do something with it.... } ตอนนี้ฉันต้องการเสริมสร้างพฤติกรรมของชั้นเรียนของฉันโดยการโยนข้อผิดพลาดถ้าdisplayCompleteNameOnInvoiceมีการเรียกก่อนที่ชื่อจะได้รับมอบหมาย ดูเหมือนจะเป็นความคิดที่ดีใช่ไหม? ฉันสามารถเพิ่มรหัสยกข้อยกเว้นให้กับgetCompleteNameวิธีการ แต่ด้วยวิธีนี้ฉันละเมิดสัญญา 'โดยนัย' กับผู้ใช้คลาส ใน getters ทั่วไปไม่ควรโยนข้อยกเว้นหากไม่ได้ตั้งค่า …

55 java  class-design 

ฉันได้อ่านคำตอบของคำถามในบรรทัดที่คล้ายกันเช่น "คุณจะให้การทดสอบหน่วยของคุณทำงานอย่างไรเมื่อทำการรีแฟคเตอร์?" ในกรณีของฉันสถานการณ์แตกต่างกันเล็กน้อยซึ่งฉันได้รับโครงการเพื่อตรวจสอบและนำไปสู่มาตรฐานที่เรามีอยู่ในขณะนี้ไม่มีการทดสอบใด ๆ สำหรับโครงการ! ฉันได้ระบุหลายสิ่งที่ฉันคิดว่าทำได้ดีกว่าเช่นไม่ผสมรหัสประเภท DAO ในเลเยอร์บริการ ก่อนที่จะทำการเปลี่ยนรูปใหม่ดูเหมือนว่าเป็นความคิดที่ดีที่จะเขียนการทดสอบสำหรับโค้ดที่มีอยู่ ปัญหาที่ฉันเห็นก็คือเมื่อฉันทำ refactor แล้วการทดสอบเหล่านั้นจะแตกในขณะที่ฉันกำลังเปลี่ยนแปลงที่ตรรกะบางอย่างจะทำและการทดสอบจะถูกเขียนด้วยโครงสร้างก่อนหน้าในใจ (ล้อเลียนอ้างอิง ฯลฯ ) ในกรณีของฉันสิ่งที่จะเป็นวิธีที่ดีที่สุดในการดำเนินการ? ฉันถูกล่อลวงให้เขียนการทดสอบเกี่ยวกับรหัส refactored แต่ฉันรู้ว่ามีความเสี่ยงที่ฉันอาจ refactor สิ่งที่ไม่ถูกต้องที่อาจเปลี่ยนพฤติกรรมที่ต้องการ ไม่ว่าจะเป็น refactor หรือการออกแบบใหม่ฉันมีความสุขที่จะเข้าใจคำศัพท์เหล่านั้นที่จะได้รับการแก้ไขในขณะนี้ฉันกำลังทำงานกับคำจำกัดความต่อไปนี้สำหรับการ refactoring "ด้วยการ refactoring ตามนิยามคุณจะไม่เปลี่ยนแปลงสิ่งที่ซอฟต์แวร์ของคุณทำ คุณเปลี่ยนวิธีการใช้งาน ". ดังนั้นฉันจะไม่เปลี่ยนแปลงสิ่งที่ซอฟต์แวร์ทำฉันจะเปลี่ยนวิธี / มันทำ เท่าเทียมกันฉันสามารถดูอาร์กิวเมนต์ว่าถ้าฉันเปลี่ยนลายเซ็นของวิธีการที่อาจถือเป็นการออกแบบใหม่ นี่เป็นตัวอย่างสั้น ๆ MyDocumentService.java (ปัจจุบัน) public class MyDocumentService { ... public List<Document> findAllDocuments() { DataResultSet rs = …

55 unit-testing  refactoring