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

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

30 agile  pair-programming 

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

30 java  type-systems  lambda  java8 

ฉันอยากรู้ว่ามันเหมาะสมหรือไม่ที่จะแบ่งโครงการที่ฉันทำงานในที่เก็บสองแห่งแทนที่จะเป็นหนึ่งโครงการ จากสิ่งที่ฉันสามารถพูดได้: ส่วนหน้าจะถูกเขียนเป็น html + js แบ็กเอนด์ใน. net แบ็กเอนด์ไม่ได้ขึ้นอยู่กับส่วนหน้าและส่วนหน้าไม่ได้ขึ้นอยู่กับส่วนแบ็คเอนด์ ส่วนหน้าจะใช้ API พักผ่อนหย่อนใจดำเนินการในแบ็กเอนด์ ส่วนหน้าสามารถโฮสต์บนเซิร์ฟเวอร์ HTTP ใด ๆ คงที่ ณ ตอนนี้ที่เก็บมีโครงสร้างนี้: ราก: ส่วนหน้า / * แบ็กเอนด์ / * ฉันคิดว่ามันเป็นความผิดพลาดที่ทำให้โครงการทั้งสองอยู่ในที่เก็บเดียวกัน เนื่องจากโปรเจ็กต์ทั้งสองไม่มีการขึ้นต่อกันระหว่างกันดังนั้นจึงควรอยู่ในที่เก็บแต่ละรายการและหากจำเป็นต้องมีที่เก็บพาเรนต์ที่มีซับโดเลชัน ฉันได้รับแจ้งว่าไม่มีประโยชน์และเราจะไม่ได้รับประโยชน์ใด ๆ จากการทำเช่นนั้น นี่คือข้อโต้แย้งของฉัน: เรามีสองโมดูลที่ไม่ได้พึ่งพากัน การมีประวัติแหล่งที่มาของทั้งสองโครงการในระยะยาวอาจทำให้สิ่งต่าง ๆ ซับซ้อน (ลองค้นหาในประวัติของบางสิ่งในส่วนหน้าในขณะที่คุณมีครึ่งหนึ่งของข้อผูกพันที่ไม่เกี่ยวข้องกับข้อบกพร่องที่คุณกำลังมองหา) ความขัดแย้งและการรวม (สิ่งนี้ไม่ควรเกิดขึ้น แต่การมีคนกดไปที่แบ็กเอนด์จะบังคับให้ผู้พัฒนารายอื่นดึงการเปลี่ยนแปลงด้านหลังเพื่อผลักดันการเปลี่ยนแปลงส่วนหน้า) นักพัฒนาซอฟต์แวร์หนึ่งรายอาจใช้งานได้เฉพาะในแบ็กเอนด์ แต่จะต้องดึงส่วนหน้าหรือวิธีอื่น ๆ เสมอ ในระยะยาวเมื่อถึงเวลาต้องปรับใช้ ในบางวิธีส่วนหน้าสามารถปรับใช้กับเซิร์ฟเวอร์แบบคงที่หลายตัวในขณะที่มีเซิร์ฟเวอร์ส่วนหลังหนึ่งตัว ในทุกกรณีผู้คนจะถูกบังคับให้โคลนทั้งแบ็กเอนด์ด้วยหรือเพื่อให้สคริปต์ที่กำหนดเองเพื่อผลักดันให้เซิร์ฟเวอร์ทั้งหมดส่วนหน้าเท่านั้นหรือเพื่อลบแบ็กเอนด์ ง่ายกว่าเพียงแค่กด / ดึงเฉพาะส่วนหน้าหรือส่วนหลังกว่าทั้งสองอย่างหากจำเป็นต้องใช้เพียงส่วนเดียว …

30 project-management  version-control  git  mercurial  organization 

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

30 testing  inheritance 

นามธรรม: ดังนั้นในขณะที่ฉันเข้าใจ (แม้ว่าฉันมีความเข้าใจที่ จำกัด มาก) มีสามมิติที่เรา (ปกติ) ทำงานร่วมกับร่างกาย: วันที่ 1 จะแสดงเป็นเส้น ที่สองจะถูกแทนด้วยตาราง ก้อนที่ 3 จะถูกแทนด้วยคิวบ์ ง่ายพอจนกว่าเราจะได้รับการ4 - มันเป็นเรื่องยากนะที่จะวาดในพื้นที่ 3D ถ้าคุณรู้ว่าสิ่งที่ฉันหมายถึง ... บางคนบอกว่ามันมีสิ่งที่จะทำอย่างไรกับเวลา คำถาม: ตอนนี้ถึงแม้ว่ามันจะไม่สมเหตุสมผลก็ตามทั้งหมดนั้นยอดเยี่ยมสำหรับฉัน คำถามของฉันไม่เกี่ยวกับเรื่องนี้หรือฉันจะถามมันใน MathSO หรือ PhysicsSO คำถามของฉันคือคอมพิวเตอร์จะจัดการกับอาร์เรย์ได้อย่างไร ฉันรู้ว่าคุณสามารถสร้างอาร์เรย์ 4D, 5D, 6D และอื่น ๆ ... ในภาษาการเขียนโปรแกรมที่แตกต่างกัน แต่ฉันต้องการที่จะรู้วิธีการทำงาน

30 theory  array 

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

30 cloud-computing 

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

30 open-source  github 

สมมติว่าฉันมีไฟล์foo.pyที่มีคลาสFoo: class Foo(object): def __init__(self, data): ... ตอนนี้ฉันต้องการเพิ่มฟังก์ชั่นที่สร้างFooวัตถุในวิธีที่แน่นอนจากแหล่งข้อมูลดิบ ฉันควรวางมันเป็นวิธีการคงที่ใน Foo หรือเป็นฟังก์ชั่นอื่นที่แยกจากกันหรือไม่? class Foo(object): def __init__(self, data): ... # option 1: @staticmethod def fromSourceData(sourceData): return Foo(processData(sourceData)) # option 2: def makeFoo(sourceData): return Foo(processData(sourceData)) ฉันไม่รู้ว่าการอำนวยความสะดวกให้กับผู้ใช้สำคัญกว่าหรือไม่: foo1 = foo.makeFoo(sourceData) หรือไม่ว่าจะสำคัญกว่าหรือไม่ในการรักษาคัปปลิ้งที่ชัดเจนระหว่างเมธอดและคลาส: foo1 = foo.Foo.fromSourceData(sourceData)

30 design  python 

มีเทคนิคเฉพาะ Java (สิ่งที่จะไม่ใช้กับ C ++) สำหรับการเขียนรหัส latency ต่ำใน Java? ฉันมักจะเห็นบทบาทที่มีความล่าช้าต่ำของ Java และพวกเขาขอประสบการณ์ในการเขียน Java ที่มีความหน่วงต่ำซึ่งบางครั้งก็ดูเหมือนเป็นช่วงเวลาสั้น ๆ เพียงคิดว่าฉันสามารถคิดว่าเป็นประสบการณ์กับ JNI จ้าง I / O โทรไปยังรหัสพื้นเมือง อาจเป็นไปได้ที่จะใช้รูปแบบการทำลายซึ่งไม่ใช่เทคโนโลยีจริง มีเคล็ดลับเฉพาะ Java สำหรับการเขียนรหัส latency ต่ำหรือไม่ ฉันรู้ว่ามี Java Real Time แบบเรียลไทม์ แต่ฉันถูกเตือนแบบเรียลไทม์ไม่เหมือนกับ latency ต่ำ ....

30 java  performance  caching  latency 

แก้วน้ำเปล่าเรียงตามลำดับต่อไปนี้: เมื่อคุณเทของเหลวลงในแก้วที่ 1 ถ้ามันเต็มแล้วของเหลวที่เพิ่มเข้ามาจะถูกใส่ลงในแก้ว 2 และ 3 ในปริมาณที่เท่ากัน เมื่อแก้ว 2 เต็มแล้วของเหลวพิเศษจะถูกปล่อยออกมาเป็น 4 และ 5 เป็นต้น เมื่อให้ของเหลว N ลิตรและความจุสูงสุดของแก้วแต่ละแก้วคือ 1 ลิตรให้ปริมาณของของเหลวในแก้วใด ๆ ถ้าคุณล้างของเหลว N ลิตรโดยเทลงในแก้วโดยเติมฟังก์ชันgetWaterInBucket(int N, int X)ที่ X คือหมายเลขแก้ว ตัวอย่างเช่นถ้าฉันต้องการมี 4 ลิตรที่จุดเริ่มต้นและฉันต้องการค้นหาน้ำในแก้ว 3 ฟังก์ชั่นคือgetWaterInBucket(4, 3) ฉันจะแก้ปัญหานี้โดยทางโปรแกรมได้อย่างไร ฉันพยายามหาวิธีแก้ปัญหาทางคณิตศาสตร์โดยใช้สามเหลี่ยมของปาสกาล สิ่งนี้ไม่ได้ผล ฉันถือว่ามันเป็นต้นไม้ดังนั้นฉันจึงสามารถเพิ่มพารามิเตอร์เช่นนี้getWaterInBucket(BTree root, int N, int X)แล้วลองแก้ปัญหาแบบเรียกซ้ำสำหรับแต่ละระดับ แต่ไม่อนุญาตให้ใช้พารามิเตอร์ในปัญหานี้ มีบางอย่างชัดเจนหรือไม่?

30 algorithms  puzzles 

มีรูปแบบการเข้ารหัสที่แนะนำ / ยอมรับโดยทั่วไปสำหรับการจัดการสถานการณ์ที่ฟังก์ชันส่งคืนค่า tuple แต่จะใช้ค่าเหล่านั้นเพียงหนึ่งค่าในภายหลัง (โปรดทราบว่านี่เป็นความหมายส่วนใหญ่สำหรับฟังก์ชั่นห้องสมุดที่ฉันไม่สามารถเปลี่ยนแปลงได้ การโทรน่าจะเกินกำลังเล็กน้อย ... )? แทนที่จะทำ a, b, c = foo() และจากนั้นก็ไม่ได้ใช้bและcควรเลือกอันใดของตัวแปรต่อไปนี้ (หรือมีอีกอันหนึ่ง): ตัวแปร 1 (ขีดล่าง) a, _, _ = foo() (ซึ่งมีความชัดเจนและเรียบง่าย แต่อาจขัดแย้งกับการ_ = gettext.gettextใช้งานในหลาย ๆ แอปพลิเคชันที่ใช้การแปล) ตัวแปร 2 (ชื่อจำลอง) a, unused, unused = foo() (ไม่น่าสนใจมากฉันคิดว่าเหมือนกันไปสำหรับชื่ออื่น ๆ เช่นdummy) ตัวแปร 3 (ดัชนี) a = foo()[0] (สำหรับฉัน()[0]ภาพลักษณ์ที่ไม่ไพเราะ…)

30 python  coding-style 

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

30 functional-programming  haskell 

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

30 productivity  version-control  solo-development 

ฉันเพิ่งอ่านว่าจะมีสองรุ่นของ Windows ที่ใช้ได้: ของ Windows RTและWindows 8 มีคนช่วยอธิบายความแตกต่างระหว่างWindows RTและWindows 8ได้ไหม? และความแตกต่างเหล่านี้อาจส่งผลกระทบต่อนักพัฒนาที่สร้างแอพสำหรับแอพอื่น นอกจากนี้WinRTคืออะไร?

30 applications  windows-8  winrt 

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

30 design  architecture