การเรียนรู้การชุมนุมช่วยในการเขียนโปรแกรมได้อย่างไร [ปิด]

ฉันเขียนโปรแกรมในภาษาระดับสูงกว่า (Python, C #, VBA, VB.NET) เป็นเวลาประมาณ 10 ปีและฉันไม่มีความเข้าใจอย่างสมบูรณ์เกี่ยวกับสิ่งที่เกิดขึ้น "ภายใต้ประทุน"

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

เพราะคุณจะเข้าใจวิธีการใช้งานจริง

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

สิ่งที่ควรคำนึงถึงคือทุกสิ่งที่เราเขียนในภาษา C # หรือ Python จำเป็นต้องได้รับการแปลเป็นลำดับขั้นตอนของการกระทำขั้นพื้นฐานที่คอมพิวเตอร์สามารถดำเนินการได้ เป็นการง่ายที่จะนึกถึงคอมพิวเตอร์ในแง่ของคลาส generics และความเข้าใจในรายการ แต่สิ่งเหล่านี้มีอยู่ในภาษาการเขียนโปรแกรมระดับสูงเท่านั้น

เราสามารถคิดถึงโครงสร้างภาษาที่ดูดีมาก แต่ก็แปลได้ไม่ดีนักในระดับต่ำ คุณจะเข้าใจได้ดีขึ้นว่าทำไมสิ่งต่าง ๆ ถึงทำงานในแบบที่พวกเขาทำ

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

สำหรับการมองอย่างรวดเร็วด้วย C เป็นอย่างไรบ้าง

#include <stdio.h>

main()
{
  puts("Hello World.");
  return(0);
}

คอมไพล์ด้วยgcc -S so.cและลองดูที่เอาต์พุตแอสเซมบลีในso.s:

 $ cat so.s

    .file   "so.c"
    .section    .rodata
.LC0:
    .string "Hello World."
    .text
.globl main
    .type   main, @function
main:
    pushl   %ebp
    movl    %esp, %ebp
    andl    $-16, %esp
    subl    $16, %esp
    movl    $.LC0, (%esp)
    call    puts
    movl    $0, %eax
    leave
    ret
    .size   main, .-main
    .ident  "GCC: (Ubuntu 4.4.3-4ubuntu5.1) 4.4.3"
    .section    .note.GNU-stack,"",@progbits

ฉันคิดว่าคำตอบที่คุณค้นหาอยู่ที่นี่: http://www.codeproject.com/Articles/89460/Why-Learn-Assembly-Language

คำพูดจากบทความ:

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

ความจริงของเรื่องนี้ก็คือยิ่งภาษาระดับสูงมีความซับซ้อนมากขึ้นและยิ่งมีการเขียน ADT (ประเภทข้อมูลนามธรรม) มากเท่าไหร่ก็จะยิ่งมีค่าใช้จ่ายมากขึ้นในการรองรับตัวเลือกเหล่านี้ ในกรณีของ. NET อาจพอง MSIL ลองนึกภาพถ้าคุณรู้จัก MSIL นี่คือที่ประกอบภาษาส่องแสง

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

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

นอกจากนี้ฉันขอแนะนำหนังสือเล่มนี้เนื่องจากมีสถาปัตยกรรมคอมพิวเตอร์แบบง่าย: ความรู้เบื้องต้นเกี่ยวกับระบบคอมพิวเตอร์: จาก Bits และ Gates ถึง C and Beyond, 2 / e Yale N. Patt, มหาวิทยาลัยเท็กซัสที่ Austin Sanjay J. Patel, มหาวิทยาลัยอิลลินอยส์ Urbana / Champaign

ในความเห็นต่ำต้อยของฉันมันไม่ได้ช่วยอะไรมาก

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

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

ฉันยอมรับว่าคำถามมากมายที่โปรแกรมเมอร์ C ++ ยังคงถามหาประโยชน์ได้รับการแจ้งโดยการรู้จักการประกอบ ตัวอย่าง: ฉันควรใช้ตัวแปร stack หรือ heap หรือไม่ ฉันควรผ่านค่าหรืออ้างอิง const? อย่างไรก็ตามในเกือบทุกกรณีฉันคิดว่าตัวเลือกเหล่านี้ควรทำตามความสามารถในการอ่านรหัสแทนที่จะประหยัดเวลาในการคำนวณ (เช่นใช้ตัวแปรสแต็คเมื่อใดก็ตามที่คุณต้องการ จำกัด ตัวแปรไว้ในขอบเขต)

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

คุณควรคุ้นเคยกับ 'ระดับลึก' หนึ่งระดับในระบบที่คุณกำลังทำงาน การข้ามไปไกลเกินไปในการเดินทางครั้งเดียวนั้นไม่เลว แต่อาจไม่เป็นประโยชน์อย่างที่ใคร ๆ ก็ปรารถนา

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

สำหรับโปรแกรมเมอร์ Java การเรียนรู้ C บางอย่างจะช่วยคุณในการจัดการหน่วยความจำการส่งผ่านข้อโต้แย้ง การเขียนไลบรารี java จำนวนมากใน C จะเป็นวิธีการที่จะเข้าใจว่าเมื่อใดจึงจะใช้ Set (คุณต้องการแฮชหรือทรีหรือไม่) การจัดการกับ char * ในสภาพแวดล้อมแบบเธรดจะช่วยในการทำความเข้าใจว่าทำไม String จึงไม่เปลี่ยนรูป

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

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

ฉันจะพูดต่อไปอีกว่าคุณไม่ควรดำน้ำในการชุมนุมก่อนที่จะเข้าใจว่าภาษาที่ไม่มีการจัดการทำงานอย่างไร มันเกือบจะเป็นการอ่านภาคบังคับ

คุณควรเรียนรู้การชุมนุมถ้าคุณต้องการที่จะลงไปอีก คุณต้องการที่จะรู้ว่าการสร้างภาษาแต่ละครั้งและทุกครั้ง มันให้ข้อมูล แต่มันมีความซับซ้อนในระดับที่แตกต่างกันมาก

หากคุณรู้จักภาษาดีคุณควรมีความรู้พื้นฐานเกี่ยวกับเทคโนโลยีอย่างน้อยระดับหนึ่งที่เป็นนามธรรม

ทำไม? เมื่อสิ่งต่าง ๆ ผิดปกติความรู้เกี่ยวกับกลไกพื้นฐานทำให้การดีบักปัญหาแปลก ๆ ง่ายขึ้นและเขียนโค้ดที่มีประสิทธิภาพมากขึ้น

การใช้ Python (/ CPython) เป็นตัวอย่างถ้าคุณเริ่มได้รับข้อผิดพลาดแปลก ๆ หรือประสิทธิภาพต่ำความรู้เกี่ยวกับการดีบักรหัส C จะมีประโยชน์มากเช่นเดียวกับความรู้เกี่ยวกับวิธีการจัดการหน่วยความจำที่นับได้ สิ่งนี้จะช่วยให้คุณรู้ว่าเมื่อใดที่จะเขียนอะไรบางอย่างเป็นส่วนขยาย C และอื่น ๆ ...

ในการตอบคำถามของคุณในกรณีนี้ความรู้เกี่ยวกับการประกอบจริง ๆ แล้วไม่ได้ช่วยนักพัฒนา Python ที่มีประสบการณ์ (ขั้นตอนมากเกินไปที่เป็นนามธรรม - สิ่งใดที่ทำใน Python จะส่งผลให้มีคำแนะนำในการประกอบจำนวนมาก)

.. แต่ถ้าคุณมีประสบการณ์กับ C แล้วรู้ว่า "ระดับต่อไปลง" (การชุมนุม) จะมีประโยชน์แน่นอน

ในทำนองเดียวกันถ้าคุณใช้ CoffeScript มันมีประโยชน์มากที่จะรู้ว่า Javascript หากคุณใช้ Clojure ความรู้เกี่ยวกับ Java / JVM จะเป็นประโยชน์

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

เขียนโปรแกรม c ขนาดเล็กและแยกเอาท์พุท นั่นคือทั้งหมดที่ อย่างไรก็ตามควรเตรียมพร้อมสำหรับรหัส "การดูแลรักษา" ที่มากขึ้นหรือน้อยลงซึ่งถูกเพิ่มเข้ามาเพื่อประโยชน์ของระบบปฏิบัติการ

แอสเซมบลีช่วยให้คุณเข้าใจสิ่งที่เกิดขึ้นภายใต้ประทุนเพราะมันเกี่ยวข้องโดยตรงกับหน่วยความจำการลงทะเบียนโปรเซสเซอร์และสิ่งที่คล้ายกัน

หากคุณต้องการที่จะใช้โลหะเปลือยโดยไม่ต้องมีความซับซ้อนของระบบปฏิบัติการที่ซับซ้อนให้ลองเขียนโปรแกรมArduino ในภาษาแอสเซมบลี

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

นี่คือสิ่งที่โจเอลเห็นคุณค่าของการใช้ภาษาในระดับที่ไม่สูง: http://www.joelonsoftware.com/articles/ThePerilsofJavaSchools.html

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

ปัญหาคือว่าด้วยภาษาระดับสูงไกลออกไปจากฮาร์ดแวร์เช่น C # หรือ Python คุณไม่ได้ชื่นชมความจริงที่ว่าทุกการเคลื่อนไหวของคุณเปลี่ยนเป็นร้อยถ้าไม่นับพันคำแนะนำเครื่องและคุณ don มีแนวโน้มที่จะเข้าใจว่าภาษาระดับสูงสองสามบรรทัดสามารถทำให้พื้นที่เก็บข้อมูลมากมายสามารถเข้าถึงและแก้ไขได้ มันไม่มากนักที่คุณจะต้องรู้อย่างแม่นยำว่าเกิดอะไรขึ้น "ใต้ผ้าห่ม" แต่คุณต้องมีความซาบซึ้งในขอบเขตของสิ่งที่เกิดขึ้นและความคิดทั่วไปเกี่ยวกับประเภทของสิ่งต่าง ๆ ที่เกิดขึ้น

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

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

ถ้าคุณเข้าใจสิ่งต่อไปนี้จากผู้ประกอบ 6502 ...

LDA variable
CLC
ADC #1
STA variable

นั่นเป็นเพียงขั้นตอนจริงๆ จากนั้นเมื่อคุณเรียนรู้ที่จะแปลว่าเป็นคำสั่งที่ได้รับมอบหมาย ...

variable = variable + 1;

คุณไม่จำเป็นต้องมีการเปรียบเทียบที่ทำให้เข้าใจผิดกับสมการทางคณิตศาสตร์ - คุณมีรูปแบบจิตที่ถูกต้องในการทำแผนที่

แก้ไข - แน่นอนถ้าคำอธิบายที่คุณได้รับLDA variableนั้นACCUMULATOR = variableเป็นสิ่งที่คุณได้รับจากบทเรียนและการอ้างอิงบางอย่างคุณจะกลับไปสู่จุดที่คุณเริ่มต้นและมันก็ไม่ได้ช่วยอะไรเลย

ฉันเรียน 6502 แอสเซมเบลอร์เป็นภาษาที่สองของฉันเป็น Commodore Basic เป็นครั้งแรกและฉันไม่ได้เรียนรู้อะไรมากมายในตอนนี้ - ส่วนหนึ่งเป็นเพราะมีการเรียนรู้น้อยมาก แต่เพราะผู้ประกอบดูเหมือนว่าน่าสนใจมาก . บางครั้งบางส่วนเพราะฉันอายุเกิน 14 ปี

ฉันไม่แนะนำให้ทำสิ่งที่ฉันทำ แต่ฉันสงสัยว่าการศึกษาตัวอย่างง่ายๆสองสามอย่างในภาษาแอสเซมเบลอร์ที่เรียบง่ายอาจเป็นสิ่งที่คุ้มค่าสำหรับการเรียนรู้ภาษาระดับสูงกว่า

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

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

บทความ " การปรับให้เหมาะสมสำหรับ SSE: กรณีศึกษา " แสดงสิ่งที่เป็นไปได้ที่จะทำถ้าคุณไปที่การชุมนุม ผู้เขียนจัดการเพื่อปรับแต่งอัลกอริทึมจาก 100 รอบ / เวกเตอร์เป็น 17 รอบ / เวกเตอร์

การเขียนในแอสเซมบลีจะไม่ให้ความเร็วเพิ่มขึ้นเนื่องจากจำนวนรายละเอียด (การจัดสรรการลงทะเบียน ฯลฯ ) คุณอาจจะเขียนอัลกอริธึมที่ไม่สำคัญที่สุด

นอกจากนี้ด้วยชุดตัวประมวลผลที่ทันสมัย ​​(อ่าน - ออกแบบหลังจาก 70-80) จะไม่ให้รายละเอียดจำนวนมากพอที่จะรู้ว่าเกิดอะไรขึ้น (นั่นคือ - ในตัวประมวลผลส่วนใหญ่) PU สมัยใหม่ (ซีพียูและ GPU) ค่อนข้างซับซ้อนเท่าที่คำแนะนำในการกำหนดตารางเวลาดำเนินไป การรู้พื้นฐานของแอสเซมบลี (หรือ pseudoassembly) จะช่วยให้เข้าใจหนังสือ / หลักสูตรสถาปัตยกรรมคอมพิวเตอร์ซึ่งจะให้ความรู้เพิ่มเติม (แคชการดำเนินการนอก MMO ฯลฯ ) โดยปกติแล้วคุณไม่จำเป็นต้องรู้จัก ISA ที่ซับซ้อนเพื่อทำความเข้าใจกับมัน (MIPS 5 ค่อนข้างเป็นที่นิยม IIRC)

ทำไมต้องเข้าใจโปรเซสเซอร์ มันอาจทำให้คุณเข้าใจมากขึ้นว่าเกิดอะไรขึ้น สมมติว่าคุณเขียนการคูณเมทริกซ์แบบไร้เดียงสา:

for i from 0 to N
    for j from 0 to N
        for k from 0 to N
            A[i][j] += B[i][k] + C[k][j]

มันอาจจะ 'ดีพอ' สำหรับจุดประสงค์ของคุณ (ถ้าเป็นเมทริกซ์ 4x4 มันอาจถูกคอมไพล์ไปยังคำแนะนำเวกเตอร์ต่อไป) อย่างไรก็ตามมีโปรแกรมที่สำคัญมากเมื่อคุณรวบรวมอาร์เรย์ขนาดใหญ่ - วิธีเพิ่มประสิทธิภาพพวกเขา? หากคุณเขียนรหัสในชุดประกอบคุณอาจมีการปรับปรุงเพียงไม่กี่% (เว้นแต่ว่าคุณจะทำเหมือนคนส่วนใหญ่ - ในทางที่ไร้เดียงสา, การลงทะเบียนต่ำกว่าปกติ, โหลด / จัดเก็บไปยังหน่วยความจำอย่างต่อเนื่อง .

อย่างไรก็ตามคุณสามารถย้อนกลับบรรทัดหลักและเพิ่มประสิทธิภาพได้อย่างน่าอัศจรรย์ (เพราะเหตุใดฉันจึงปล่อยให้มันเป็น 'การบ้าน') - IIRC ขึ้นอยู่กับปัจจัยต่าง ๆ สำหรับการฝึกอบรมขนาดใหญ่

for i from 0 to N
    for k from 0 to N
        for j from 0 to N
            A[i][j] += B[i][k] + C[k][j]

ที่กล่าวว่า - มีการทำงานกับคอมไพเลอร์ที่สามารถทำได้ ( กราไฟท์สำหรับ gcc และพอลลี่สำหรับทุกสิ่งที่ใช้ LLVM) พวกเขาสามารถแปลงให้เป็น (ขออภัย - ฉันกำลังเขียนบล็อกจากหน่วยความจำ):

for i from 0 to N
    for K from 0 to N/n
        for J from 0 to N/n
            for kk from 0 to n
                for jj from 0 to n
                    k = K*n + kk
                    j = J*n + jj
                    A[i][j] += B[i][k] + C[k][j]

เพื่อสรุป - รู้พื้นฐานของแอสเซมบลีช่วยให้คุณสามารถขุด 'รายละเอียด' ต่าง ๆ จากการออกแบบโปรเซสเซอร์ซึ่งจะช่วยให้คุณสามารถเขียนโปรแกรมได้เร็วขึ้น มันอาจเป็นการดีที่จะทราบความแตกต่างระหว่างสถาปัตยกรรม RISC / CISC หรือ VLIW / vector processor / SIMD / ... อย่างไรก็ตามฉันจะไม่เริ่มต้นด้วย x86 เนื่องจากพวกเขามีแนวโน้มที่จะค่อนข้างซับซ้อน (อาจเป็น ARM ด้วย) - การรู้ว่าอะไรคือ register เป็นต้น IMHO นั้นเพียงพอสำหรับการเริ่มต้น

ปกติแล้วมันสำคัญมากสำหรับการแก้ไขจุดบกพร่อง คุณจะทำอย่างไรเมื่อระบบหยุดกลางคำสั่งและข้อผิดพลาดไม่สมเหตุสมผล มันมีปัญหาน้อยกว่ากับภาษา. NET ตราบใดที่คุณใช้รหัสที่ปลอดภัยเท่านั้นระบบจะปกป้องคุณจากสิ่งที่เกิดขึ้นภายใต้ประทุน

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

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

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

ฉันอยากจะแนะนำการเรียนรู้อัลกอริทึม: การเรียงลำดับรายการที่เชื่อมโยงต้นไม้ไบนารี hashing ฯลฯ

เรียนรู้เสียงกระเพื่อมดูโครงสร้างและการตีความของโปรแกรมคอมพิวเตอร์ groups.csail.mit.edu/mac/classes/6.001/abelson-sussman-lectures หลักสูตรวิดีโอนี้จะสอนทุกสิ่งที่คุณจำเป็นต้องรู้รวมถึงอัลกอริทึม (วิธีการทำทุกอย่างขึ้นอยู่กับ คำสั่งดั้งเดิมสองสามคำ, เสียงกระเพื่อมดั้งเดิมและคำสั่งแอสเซมเบลอร์บางรายการ)

ในที่สุดหากคุณต้องเรียนรู้แอสเซมเบลอร์เรียนรู้ง่าย ๆ เช่น ARM (เช่นเดียวกับที่ใช้ในอุปกรณ์มากกว่า x86 ประมาณ 4 เท่า)

คำตอบก็คือเพียงเพราะภาษาที่คุณใช้ต้องแปลหรือเรียบเรียงเป็นแอสเซมเบลอร์ในตอนท้าย ไม่ว่าจะเป็นภาษาหรือเครื่อง

การออกแบบภาษานั้นมาจากการทำงานของ CPU เพิ่มเติมเกี่ยวกับโปรแกรมระดับต่ำ, น้อยกว่าสำหรับโปรแกรมระดับสูง

ฉันจะจบด้วยการบอกว่ามันไม่เพียง แต่คุณจะต้องรู้แอสเซมเบลอร์เล็ก ๆ น้อย ๆ แต่สถาปัตยกรรมซีพียูที่คุณเรียนรู้จากการเรียนรู้แอสเซมเบลอร์

ตัวอย่างบางส่วน: มีโปรแกรมเมอร์ Java จำนวนมากที่ไม่เข้าใจว่าทำไมถึงไม่สามารถทำงานได้และยังไม่รู้ว่าจะเกิดอะไรขึ้นเมื่อคุณเรียกใช้

String a = "X";
String b = "X";
if(a==b)  
    return true;

หากคุณรู้จักแอสเซมเบลอร์เล็กน้อยคุณจะรู้เสมอว่ามันไม่เหมือนกับเนื้อหาของตำแหน่งหน่วยความจำเทียบกับตัวเลขในตัวแปรพอยน์เตอร์ที่ "ชี้" ไปยังตำแหน่งนั้น

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

หากคุณรวบรวมสิ่งที่เห็นได้ชัดเจนว่าเกิดอะไรขึ้นหากไม่ใช่มันซับซ้อนมากที่จะอธิบายว่าผู้เขียนส่วนใหญ่แค่โกหกคุณอย่างเคร่งศาสนา

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