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

ฉันกำลังทำงานบนเว็บไซต์ที่จะอนุญาตให้ผู้ใช้เข้าสู่ระบบโดยใช้ข้อมูลประจำตัว OAuth จาก Twitter, Google และอื่น ๆ ในการทำเช่นนี้ฉันต้องลงทะเบียนกับผู้ให้บริการที่หลากหลายเหล่านี้และรับคีย์ API ลับสุดยอดที่ฉันมี เพื่อปกป้องด้วยคำมั่นสัญญาจากส่วนต่างๆของร่างกาย หากคีย์ของฉันถูก ganked ส่วนนั้นจะถูกดึง คีย์ API ต้องเดินทางไปพร้อมกับที่มาของฉันเนื่องจากมันถูกใช้ที่รันไทม์เพื่อทำการร้องขอการตรวจสอบสิทธิ์ ในกรณีของฉันคีย์ต้องมีอยู่ภายในแอปพลิเคชันในไฟล์กำหนดค่าหรือภายในโค้ดเอง นั่นไม่ใช่ปัญหาเมื่อฉันสร้างและเผยแพร่จากเครื่องเดียว อย่างไรก็ตามเมื่อเราส่งการควบคุมแหล่งที่มาลงในการผสมสิ่งต่าง ๆ ก็ซับซ้อนขึ้น ในฐานะที่ฉันเป็นไอ้เลวราคาถูกฉันก็อยากใช้บริการควบคุมแหล่งข้อมูลฟรีเช่น TFS ในคลาวด์หรือ GitHub สิ่งนี้ทำให้ฉันมีปริศนาเล็กน้อย: ฉันจะรักษาร่างกายของฉันให้เหมือนเดิมได้อย่างไรเมื่อคีย์ API ของฉันอยู่ในรหัสของฉันและรหัสของฉันจะมีอยู่ในที่เก็บสาธารณะ ฉันสามารถนึกถึงวิธีการต่าง ๆ ในการจัดการกับสิ่งนี้ แต่ไม่มีวิธีใดที่น่าพอใจ ฉันสามารถลบข้อมูลส่วนตัวทั้งหมดจากรหัสและแก้ไขกลับมาหลังจากการใช้งาน นี่จะเป็นความเจ็บปวดที่รุนแรงในการติดตั้ง (ฉันจะไม่ให้รายละเอียดหลาย ๆ วิธี) และไม่ใช่ตัวเลือก ฉันสามารถเข้ารหัสได้ แต่เมื่อฉันต้องถอดรหัสมันทุกคนที่มีแหล่งที่มาสามารถคิดวิธีการดังกล่าว ไม่มีจุดหมาย ฉันสามารถจ่ายสำหรับการควบคุมแหล่งข้อมูลส่วนตัว ฮ่า ๆ j / k ใช้เงินไหม …

217 project-management  version-control  development-process  api 

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

215 design  optimization  architecture 

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

215 open-source 

ฉันเขียนรหัส ES6 จำนวนมากสำหรับ io.js เมื่อเร็ว ๆ นี้ มีโค้ดไม่มากนักในการเรียนรู้ดังนั้นฉันรู้สึกเหมือนว่าฉันกำหนดอนุสัญญาของตัวเองเมื่อฉันไป คำถามของฉันเป็นเรื่องเกี่ยวกับเวลาที่จะใช้VSconstlet constฉันได้รับการใช้กฎนี้ถ้าเป็นไปได้ใช้ ใช้เฉพาะletเมื่อคุณรู้ว่าค่าจำเป็นต้องเปลี่ยนแปลง (คุณสามารถย้อนกลับและเปลี่ยน a เป็นconsta letได้ในภายหลังหากคุณต้องการเปลี่ยนค่าของมันในภายหลัง) เหตุผลหลักสำหรับกฎนี้คือมันง่ายที่จะใช้อย่างสม่ำเสมอ ไม่มีพื้นที่สีเทา สิ่งที่เป็นเมื่อฉันใช้กฎนี้ในทางปฏิบัติ 95% constของการประกาศของฉัน และนี่ดูแปลกสำหรับฉัน ฉันแค่ใช้letสำหรับสิ่งต่าง ๆiในforวงหรือบางครั้งสำหรับสิ่งต่าง ๆ เช่นผลรวมสะสมฟีโบนักชี (ซึ่งไม่ได้เกิดขึ้นมากในชีวิตจริง) ฉันรู้สึกประหลาดใจกับสิ่งนี้ - ปรากฎ 95% ของ 'ตัวแปร' ในรหัส ES5 ของฉันจนถึงปัจจุบันเป็นค่าที่ไม่เปลี่ยนแปลง แต่การเห็นconstรหัสของฉันทั่วรู้สึกผิดอย่างใด ดังนั้นคำถามของฉันคือ: ตกลงไหมที่จะใช้constสิ่งนี้มาก? ฉันควรจะทำสิ่งต่าง ๆ เช่นconst foo = function () {...};? หรือฉันควรสำรองconstไว้สำหรับสถานการณ์แบบนั้นซึ่งคุณกำลังเขียนโค้ดที่ด้านบนของโมดูลอย่างหนัก - แบบที่คุณทำในรูปแบบเต็มแคปเช่นconst MARGIN_WIDTH …

214 javascript  es6 

คอมไพเลอร์ขั้นสูงเช่นgccรหัสคอมไพล์ลงในไฟล์ที่เครื่องสามารถอ่านได้ตามภาษาที่เขียนโค้ดนั้น (เช่น C, C ++ เป็นต้น) ในความเป็นจริงพวกเขาตีความความหมายของแต่ละรหัสตามห้องสมุดและฟังก์ชั่นของภาษาที่เกี่ยวข้อง ช่วยแก้ให้ด้วยนะถ้าฉันผิด. ฉันต้องการเข้าใจคอมไพเลอร์โดยการเขียนคอมไพเลอร์พื้นฐาน (อาจเป็น C) เพื่อคอมไพล์ไฟล์สแตติก (เช่น Hello World ในไฟล์ข้อความ) ฉันลองทำแบบฝึกหัดและหนังสือบางเล่ม แต่ทั้งหมดสำหรับกรณีจริง พวกเขาจัดการกับการรวบรวมรหัสแบบไดนามิกที่มีความหมายเชื่อมต่อกับภาษาที่เกี่ยวข้อง ฉันจะเขียนคอมไพเลอร์พื้นฐานเพื่อแปลงข้อความคงเป็นไฟล์ที่เครื่องอ่านได้อย่างไร ขั้นตอนต่อไปจะแนะนำตัวแปรในคอมไพเลอร์ ลองนึกภาพว่าเราต้องการเขียนคอมไพเลอร์ที่รวบรวมเฉพาะบางฟังก์ชั่นของภาษา ขอแนะนำบทเรียนและแหล่งข้อมูลเชิงปฏิบัติที่ได้รับความนิยมอย่างสูง :-)

214 c  compiler  compilation  gcc 

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

214 design  design-patterns  business-rules  prolog  logic-programming 

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

211 unit-testing  testing 

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

210 object-oriented  encapsulation 

ครู t-sql ของฉันบอกเราว่าการตั้งชื่อคอลัมภ์ PK "Id" ของเรานั้นถือว่าเป็นการฝึกที่ไม่ดีโดยไม่มีคำอธิบายใด ๆ เพิ่มเติม เหตุใดการตั้งชื่อคอลัมน์คอลัมน์ "PK" ของตาราง PK จึงถือว่าไม่เหมาะสม

210 sql  naming  tsql 

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

209 object-oriented-design 

ฉันอ่านหนังสือชื่อClean Codeของ Robert C. Martin แล้ว ในหนังสือเล่มนี้ฉันได้เห็นวิธีการมากมายในการทำความสะอาดโค้ดเช่นการเขียนฟังก์ชั่นเล็ก ๆ การเลือกชื่ออย่างระมัดระวัง ฯลฯ ดูเหมือนว่าหนังสือที่น่าสนใจที่สุดเกี่ยวกับรหัสที่ฉันอ่าน อย่างไรก็ตามวันนี้เจ้านายของฉันไม่ชอบวิธีที่ฉันเขียนโค้ดหลังจากอ่านหนังสือเล่มนี้ ข้อโต้แย้งของเขาคือ การเขียนฟังก์ชั่นเล็ก ๆ เป็นความเจ็บปวดเพราะมันบังคับให้คุณย้ายเข้าไปในฟังก์ชั่นเล็ก ๆ แต่ละอันเพื่อดูว่าโค้ดกำลังทำอะไรอยู่ ใส่ทุกอย่างไว้ในลูปหลักหลักแม้ว่าลูปหลักจะมีมากกว่า 300 บรรทัดมันจะอ่านเร็วขึ้น เขียนฟังก์ชั่นเล็ก ๆ เท่านั้นหากคุณต้องทำซ้ำรหัส อย่าเขียนฟังก์ชั่นที่มีชื่อของความคิดเห็นใส่รหัสบรรทัดที่ซับซ้อนของคุณ (3-4 บรรทัด) ด้วยความคิดเห็นด้านบน คุณสามารถแก้ไขโค้ดที่ล้มเหลวได้เช่นเดียวกัน สิ่งนี้ขัดต่อทุกสิ่งที่ฉันอ่าน ปกติคุณเขียนรหัสได้อย่างไร หนึ่งวงใหญ่หลักไม่มีฟังก์ชั่นเล็ก ๆ ? ภาษาที่ฉันใช้ส่วนใหญ่เป็นจาวาสคริปต์ ตอนนี้ฉันมีปัญหาในการอ่านเนื่องจากฉันได้ลบฟังก์ชั่นที่ตั้งชื่อไว้อย่างชัดเจนแล้วนำทุกอย่างมารวมกันเป็นวงใหญ่ อย่างไรก็ตามเจ้านายของฉันชอบวิธีนี้ ตัวอย่างหนึ่งคือ: // The way I would write it if (isApplicationInProduction(headers)) { phoneNumber = …

209 design-patterns  refactoring  clean-code  functions 

ฉันพยายามหาทางเลือกในการใช้ตัวแปรทั่วโลกในรหัสดั้งเดิม แต่คำถามนี้ไม่เกี่ยวกับทางเลือกทางเทคนิคผมส่วนใหญ่กังวลเกี่ยวกับคำศัพท์ ทางออกที่ชัดเจนคือการส่งผ่านพารามิเตอร์เข้าสู่ฟังก์ชั่นแทนที่จะใช้โกลบอล ใน codebase ดั้งเดิมนี้หมายความว่าฉันต้องเปลี่ยนฟังก์ชั่นทั้งหมดในสายโซ่ยาวระหว่างจุดที่จะใช้ค่าในที่สุดและฟังก์ชั่นที่ได้รับพารามิเตอร์ก่อน higherlevel(newParam)->level1(newParam)->level2(newParam)->level3(newParam) newParamก่อนหน้านี้ซึ่งเคยเป็นตัวแปรทั่วโลกในตัวอย่างของฉัน แต่มันอาจเป็นค่าฮาร์ดโค้ดที่ก่อนหน้านี้แทน ประเด็นก็คือว่าตอนนี้ค่าของ newParam จะได้รับที่higherlevel()และมีการ "เดินทาง" level3()ทุกวิธีการ ฉันสงสัยว่ามีชื่อ (s)สำหรับสถานการณ์ / รูปแบบเช่นนี้ซึ่งคุณต้องเพิ่มพารามิเตอร์ในฟังก์ชั่นมากมายที่เพียงแค่ "ส่ง" ค่าที่ไม่เปลี่ยนแปลง หวังว่าการใช้คำศัพท์ที่เหมาะสมจะช่วยให้ฉันค้นหาทรัพยากรเพิ่มเติมเกี่ยวกับโซลูชันสำหรับการออกแบบใหม่และอธิบายสถานการณ์นี้ให้เพื่อนร่วมงานทราบ

209 design-patterns  terminology  anti-patterns  parameters  globals 

ฉันเป็นนักพัฒนารุ่นน้องในรุ่นพี่และกำลังดิ้นรนมากกับการเข้าใจความคิดเหตุผล ฉันกำลังอ่านการออกแบบที่ขับเคลื่อนด้วยโดเมน (DDD) และไม่เข้าใจว่าทำไมเราต้องสร้างคลาสจำนวนมาก ถ้าเราทำตามวิธีการออกแบบซอฟต์แวร์เราจะจบด้วยชั้นเรียน 20-30 ชั้นซึ่งสามารถแทนที่ได้ด้วยไฟล์มากที่สุดสองไฟล์และฟังก์ชั่น 3-4 อย่าง ใช่มันอาจยุ่งเหยิง แต่มันสามารถดูแลและอ่านได้มากกว่า เมื่อใดก็ตามที่ฉันต้องการดูว่าบางอย่างEntityTransformationServiceImplทำอะไรฉันต้องติดตามคลาสอินเทอร์เฟซการเรียกใช้ฟังก์ชันการสร้างการสร้างและอื่น ๆ มากมาย คณิตศาสตร์ง่าย ๆ : รหัสจำลอง 60 บรรทัดเทียบกับ 10 คลาส X 10 (สมมติว่าเรามี logics ที่แตกต่างกันโดยสิ้นเชิง) = 600 บรรทัดของรหัสยุ่งกับ 100 ชั้นเรียน + อีกมากมายที่จะรวมและจัดการ อย่าลืมเพิ่มการฉีดพึ่งพา อ่านรหัสยุ่ง 600 เส้น = หนึ่งวัน 100 คลาส = หนึ่งสัปดาห์ยังคงลืมว่าหนึ่งจะทำอะไรเมื่อ ทุกคนบอกว่าง่ายต่อการบำรุงรักษา แต่เพื่ออะไร ทุกครั้งที่คุณเพิ่มฟังก์ชันการทำงานใหม่คุณจะเพิ่มคลาสอีกห้าคลาสด้วยโรงงานหน่วยงานบริการและค่านิยม ฉันรู้สึกว่ารหัสประเภทนี้เคลื่อนที่ช้ากว่ารหัสที่ยุ่งเหยิงมาก สมมติว่าถ้าคุณเขียนรหัสยุ่ง 50K …

209 design-patterns  domain-driven-design  source-code 

ฉันเข้าใจว่าองค์ประกอบใดที่อยู่ใน OOP แต่ฉันไม่สามารถเข้าใจอย่างชัดเจนว่าการรวมคืออะไร มีคนอธิบายได้ไหม

206 object-oriented 

เมื่อดูที่การเปรียบเทียบดูเหมือนว่าฉันอาจมีการแมป 1: 1 ระหว่างชุดคุณลักษณะของพวกเขา แต่ข้อความที่อ้างถึงบ่อยครั้งก็คือ "Mercurial is easy" พื้นฐานของข้อความนี้คืออะไร? (ถ้ามี)

204 git  mercurial