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

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

68 object-oriented  class  methods  static-methods  access-modifiers 

พิจารณาคลาสต่อไปนี้: class Person: def __init__(self, name, age): self.name = name self.age = age เพื่อนร่วมงานของฉันมักจะนิยามเช่นนี้: class Person: name = None age = None def __init__(self, name, age): self.name = name self.age = age เหตุผลหลักสำหรับสิ่งนี้คือตัวเลือกที่แก้ไขจะแสดงคุณสมบัติของการเติมข้อความอัตโนมัติ Noneส่วนตัวผมไม่ชอบหลังหนึ่งเพราะมันทำให้รู้สึกว่าชั้นมีคุณสมบัติเหล่านั้นตั้งค่าให้ไม่มี อันไหนจะเป็นการฝึกฝนที่ดีกว่าและด้วยเหตุผลอะไร

68 python 

บทของลุงบ็อบเกี่ยวกับชื่อในClean Codeแนะนำให้คุณหลีกเลี่ยงการเข้ารหัสในชื่อส่วนใหญ่เกี่ยวกับสัญกรณ์ฮังการี เขายังกล่าวถึงการลบIคำนำหน้าจากอินเทอร์เฟซโดยเฉพาะ แต่ไม่แสดงตัวอย่างของสิ่งนี้ สมมติว่า: การใช้อินเตอร์เฟสเป็นส่วนใหญ่เพื่อให้สามารถทดสอบได้ผ่านการฉีดแบบพึ่งพา ในหลายกรณีสิ่งนี้นำไปสู่การมีอินเทอร์เฟซเดียวกับตัวดำเนินการเดียว ยกตัวอย่างเช่นสองคนนี้ควรตั้งชื่ออะไร ParserและConcreteParser? ParserและParserImplementation? public interface IParser { string Parse(string content); string Parse(FileInfo path); } public class Parser : IParser { // Implementations } หรือฉันควรเพิกเฉยต่อข้อเสนอแนะนี้ในกรณีการดำเนินการแบบครั้งเดียวเช่นนี้หรือไม่?

68 c#  naming  clean-code  naming-standards 

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

68 git  gitflow 

สมมติว่ามีโปรแกรมที่ค่อนข้างใหญ่ (พูด 900k SLOC ใน C #) ทุกความเห็น / บันทึกไว้อย่างละเอียดจัดระเบียบดีและทำงานได้ดี ฐานรหัสทั้งหมดเขียนขึ้นโดยนักพัฒนาอาวุโสคนเดียวซึ่งไม่ได้อยู่กับ บริษัท อีกต่อไป รหัสทั้งหมดนั้นสามารถทำการทดสอบได้เหมือนเดิมและ IoC นั้นถูกใช้ไปตลอด - ยกเว้นด้วยเหตุผลแปลก ๆ บางอย่างที่พวกเขาไม่ได้เขียนการทดสอบหน่วยใด ๆ ตอนนี้ บริษัท ของคุณต้องการแยกรหัสและต้องการเพิ่มการทดสอบหน่วยเพื่อตรวจสอบเมื่อมีการเปลี่ยนแปลงการทำงานหลักของระบบ การเพิ่มการทดสอบเป็นความคิดที่ดีหรือไม่ ถ้าเป็นเช่นนั้นเราจะเริ่มจากสิ่งนี้ได้อย่างไร แก้ไข ตกลงดังนั้นฉันไม่ได้คาดหวังคำตอบที่สร้างข้อโต้แย้งที่ดีสำหรับข้อสรุปที่ตรงกันข้าม ปัญหาอาจจะออกจากมือของฉันอยู่ดี ฉันได้อ่าน "คำถามที่ซ้ำกัน" เช่นกันและฉันทามติทั่วไปคือ "การทดสอบการเขียนเป็นสิ่งที่ดี" ... ใช่ แต่ไม่เป็นประโยชน์ในกรณีนี้โดยเฉพาะ ฉันไม่คิดว่าฉันอยู่คนเดียวที่นี่ในการพิจารณาการทดสอบการเขียนสำหรับระบบเดิม ฉันจะทำตัวชี้วัดว่าใช้เวลาเท่าไรและมีกี่ครั้งที่การทดสอบใหม่ตรวจพบปัญหา (และกี่ครั้งที่พวกเขาไม่ทำ) ฉันจะกลับมาและอัปเดตปีนี้จากผลลัพธ์ของฉัน สรุปผลการศึกษา ดังนั้นจึงปรากฎว่าเป็นไปไม่ได้ที่จะเพิ่มการทดสอบหน่วยในโค้ดที่มีอยู่ด้วยลักษณะของออร์โธดอกซ์ เมื่อโค้ดทำงานคุณจะไม่สามารถทำการทดสอบของคุณได้แสงสีแดง / สีเขียว - เขียวก็มักจะไม่ชัดเจนว่าพฤติกรรมใดที่มีความสำคัญในการทดสอบไม่ชัดเจนว่าจะเริ่มต้นที่ใด ที่จริงแล้วการถามคำถามนี้พลาดประเด็นสำคัญในการเขียนแบบทดสอบในตอนแรก ในกรณีส่วนใหญ่ฉันพบว่ามันง่ายกว่าจริง ๆ …

68 unit-testing  tdd  maintenance 

ฉันมีวิธีส่วนตัวในชั้นทดสอบของฉันที่สร้างBarวัตถุที่ใช้กันทั่วไป คอนBarสตรัคsomeMethod()วิธีการโทรในวัตถุที่เยาะเย้ยของฉัน: private @Mock Foo mockedObject; // My mocked object ... private Bar getBar() { Bar result = new Bar(mockedObject); // this calls mockedObject.someMethod() } ในบางวิธีการทดสอบของฉันฉันต้องการตรวจสอบsomeMethodก็ถูกเรียกใช้โดยการทดสอบนั้น สิ่งต่อไปนี้: @Test public void someTest() { Bar bar = getBar(); // do some things verify(mockedObject).someMethod(); // <--- will fail } สิ่งนี้ล้มเหลวเนื่องจากวัตถุที่เยาะเย้ยได้someMethodเรียกใช้สองครั้ง ฉันไม่ต้องการวิธีการทดสอบของฉันจะดูแลเกี่ยวกับผลข้างเคียงของฉันgetBar()วิธีจึงจะเหมาะสมที่จะตั้งค่าวัตถุจำลองของฉันในตอนท้ายของgetBar()? private Bar …

68 java  mocking 

ฉันเป็นผู้เริ่มต้นงูใหญ่และฉันเพิ่งเรียนรู้เทคนิคที่เกี่ยวข้องกับพจนานุกรมและฟังก์ชั่น ไวยากรณ์เป็นเรื่องง่ายและดูเหมือนว่าเป็นเรื่องเล็กน้อย แต่ความรู้สึกของฉันหลามรู้สึกเสียวซ่า มีบางอย่างบอกฉันว่านี่เป็นแนวคิดที่ลึกและไพเราะมากและฉันก็ไม่เข้าใจถึงความสำคัญของมัน ใครสามารถใส่ชื่อให้กับเทคนิคนี้และอธิบายว่ามันมีประโยชน์หรือไม่? เทคนิคคือเมื่อคุณมีพจนานุกรมไพ ธ อนและฟังก์ชั่นที่คุณตั้งใจจะใช้ คุณแทรกองค์ประกอบพิเศษลงใน dict ที่มีค่าเป็นชื่อของฟังก์ชั่น เมื่อคุณพร้อมที่จะเรียกฟังก์ชั่นที่คุณออกโทรทางอ้อมโดยอ้างถึงองค์ประกอบ Dict ไม่ใช่ฟังก์ชั่นตามชื่อ ตัวอย่างที่ฉันใช้งานมาจาก Learn Python the Hard Way, 2nd Ed (นี่เป็นรุ่นที่มีให้เมื่อคุณสมัครใช้งานผ่านUdemy.comแต่น่าเสียดายที่เวอร์ชัน HTML ที่ใช้งานได้ฟรีปัจจุบันเป็น Ed 3 และไม่มีตัวอย่างนี้อีกต่อไป) ในการถอดความ: # make a dictionary of US states and major cities cities = {'San Diego':'CA', 'New York':'NY', 'Detroit':'MI'} # define a function …

68 python  syntax  functions  dictionary 

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

68 functional-programming  functions  random 

ฉันรู้เครื่องมือต่างๆ / บริการที่ให้การท่องเว็บและการจัดการ DVCS เช่นBitbucket , Github , เตาเผา , SCM-ManagerและRhodecode อย่างไรก็ตามกรณีการใช้งานที่ฉันกำลังพิจารณานั้นเป็นสิ่งหนึ่งที่: ซอร์สโค้ดใด ๆ จะต้องอยู่ในเซิร์ฟเวอร์ภายในของนายจ้าง การแก้ปัญหาจะต้องเป็นโอเพนซอร์ส ควรให้ประสบการณ์เช่น Bitbucket หรือ Github รวมถึงวิกิโครงการการเรียกดูและการจัดการพื้นที่เก็บข้อมูลและการเข้ารหัสทางสังคมเช่นการตรวจสอบรหัส วิธีแก้ปัญหาควรมีการสนับสนุนแบบ Mercurial (หากไม่รองรับ DVCS อื่น ๆ ) ในจำนวนนี้มีเพียง SCM-Manager และ RhodeCode เท่านั้นที่เข้ามาใกล้เพราะสามารถติดตั้งบนเซิร์ฟเวอร์ของคุณเองและเป็นโอเพ่นซอร์ส อย่างไรก็ตามพวกเขาไม่มีประสบการณ์ Bitbucket หรือ Github ไม่มีตัวติดตามปัญหาหรือ wiki และ UI ในขณะที่ใช้งานได้ไม่สามารถเทียบเท่ากับ Github หรือ Bitbucket ได้ ฉันสามารถเข้าใกล้กับ Trac หรือ Redmine …

68 open-source  web-applications  dvcs  free-software 

ในบางรหัสที่ฉันกำลังตรวจสอบอยู่ฉันเห็นสิ่งที่มีค่าเทียบเท่ากับสิ่งต่อไปนี้: public class Foo { private Bar bar; public MethodA() { bar = new Bar(); bar.A(); bar = null; } public MethodB() { bar = new Bar(); bar.B(); bar = null; } } สนามbarที่นี่เป็นเหตุผลตัวแปรท้องถิ่นเช่นค่าของมันจะไม่เคยตั้งใจที่จะยังคงมีอยู่ทั่วโทรวิธี แต่เนื่องจากหลายวิธีในFooความต้องการวัตถุของการพิมพ์Bar, Barผู้เขียนรหัสเดิมได้ทำเพียงแค่ด้านการพิมพ์ เห็นได้ชัดว่ามันไม่ถูกต้องใช่มั้ย antipattern นี้มีชื่อหรือไม่?

68 object-oriented  terminology  anti-patterns 

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

68 git  version-control  project-management 

ฉันกำลังสัมภาษณ์กับ "ความภาคภูมิใจในทักษะชวาของฉัน" - มองคน เขาถามฉันว่า " คุณมีความรู้เกี่ยวกับคลาส Java IO .. พูดอย่างไร .. แฮชแม็พ " เขาขอให้ฉันเขียนโค้ดจาวาลงบนกระดาษ - ยกตัวอย่างคลาสและเรียกวิธีการอย่างใดอย่างหนึ่งของอินสแตนซ์ เมื่อฉันเสร็จเขาบอกว่าโปรแกรมของฉันจะไม่ทำงาน หลังจากการคิดอย่างจริงจัง 5 นาทีฉันก็เลิกและถามว่าทำไม เขาบอกว่าฉันไม่ได้เขียนฟังก์ชั่นหลักดังนั้นมันจะไม่ทำงาน บนกระดาษ. [ฉันโกรธเกินไปที่จะทำเรื่องโง่ ๆ ต่อไป ... ] เชื่อฉันเถอะว่ามันไม่ใช่คำถามที่หลอกลวงหรือการประเมินการจัดการด้านจิตใจหรือความโกรธ ฉันสามารถบอกได้จากใบหน้าของเขาเขาภูมิใจในคำถามเหล่านี้ "ผู้พัฒนา " คนนั้นควรที่จะ " ตัดสิน " ผู้สมัคร ฉันสามารถคิดหลายสิ่ง: ตีเขาด้วยเก้าอี้ (ซึ่งฉันอยากอย่างยิ่ง) และเดินออกไป เพียงแค่เดินออกไป เยาะเย้ยเขาโดยบอกว่าเขาไม่สมเหตุสมผล ให้เขารู้อย่างสุภาพว่าเขาไม่เข้าท่าและพยายามตอบคำถาม อย่าบอกเขาเลย แต่เพียงแค่พยายามตอบคำถาม จนถึงตอนนี้ฉันได้ลองแค่ 4 และ 5 …

68 interview 

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

68 packages  dependency-management  package-managers 

ข้อดีอย่างหนึ่งของการใช้ DVCS คือเวิร์กโฟลว์edit-commit-merge (การแก้ไขมากกว่าการผสานผสานกระทำบ่อยครั้งบังคับใช้โดย CVCS) การอนุญาตให้บันทึกการเปลี่ยนแปลงที่ไม่ซ้ำกันแต่ละครั้งในที่เก็บซึ่งเป็นอิสระจากการรวมกันทำให้มั่นใจได้ว่าDAGสะท้อนถึงสายเลือดที่แท้จริงของโครงการอย่างถูกต้อง ทำไมเว็บไซต์จำนวนมากถึงพูดถึงความต้องการที่จะ "หลีกเลี่ยงการรวมคอมมิท"? การไม่รวมการกระทำก่อนหน้าหรือการทำโพสต์ใหม่เข้าด้วยกันทำให้ยากต่อการแยกการถดถอยการย้อนกลับการเปลี่ยนแปลงที่ผ่านมา ฯลฯ จุดชี้แจง:พฤติกรรมเริ่มต้นสำหรับ DVCS คือการสร้างการรวมการกระทำ ทำไมหลายสถานที่พูดถึงความปรารถนาที่จะเห็นประวัติศาสตร์การพัฒนาเชิงเส้นที่ซ่อนการกระทำเหล่านี้ไว้?

68 version-control  git  dvcs  merging 

ฉันเริ่มสร้างแอพใน 3 เลเยอร์ (DAL, BL, UI) [ส่วนใหญ่จัดการกับ CRM, รายงานการขายและสินค้าคงคลัง] เพื่อนร่วมงานคนหนึ่งบอกฉันว่าฉันต้องย้ายไปที่รูปแบบเลเยอร์บริการซึ่งนักพัฒนาซอฟต์แวร์มาจากรูปแบบการบริการจากประสบการณ์ของพวกเขาและเป็นวิธีที่ดีกว่าในการออกแบบแอปพลิเคชันส่วนใหญ่ เขากล่าวว่าจะง่ายกว่ามากในการรักษาแอพพลิเคชั่นในอนาคต โดยส่วนตัวแล้วฉันได้รับความรู้สึกว่ามันเป็นเพียงการสร้างสิ่งที่ซับซ้อนมากขึ้นและฉันก็ไม่สามารถเห็นผลประโยชน์มากมายจากสิ่งนี้ที่จะพิสูจน์ได้ แอพนี้มี UI ขนาดเล็กเพิ่มเติมที่ใช้ฟังก์ชั่นแอปพลิเคชั่นเดสก์ท็อปบางส่วน (แต่มีเพียงไม่กี่) ดังนั้นฉันจึงพบว่าตัวเองทำซ้ำรหัสบางส่วน (แต่ไม่มาก) เพียงเพราะการทำซ้ำรหัสบางอย่างฉันจะไม่แปลงเป็นบริการที่มุ่งเน้น แต่เขาบอกว่าฉันควรใช้ต่อไปเพราะโดยทั่วไปแล้วมันเป็นสถาปัตยกรรมที่ดีมากทำไมโปรแกรมเมอร์จึงหลงใหลในบริการ ฉันพยายาม google บนมัน แต่ฉันยังคงสับสนและไม่สามารถตัดสินใจได้ว่าจะทำอย่างไร

68 design-patterns  architecture  web-services  services  service