มือใหม่ควรใช้การเติมข้อความอัตโนมัติ IDE (Intellisense) หรือไม่ [ปิด]

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

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

ในทางกลับกันฉันกลัวว่าการพึ่งพาการเติมข้อความอัตโนมัติ IDE ก่อนหน้านี้จะทำให้พวกเขาไม่เข้าใจแนวคิดหรือสามารถทำงานได้หากพวกเขาพบตัวเองในวันเดียวด้วยเครื่องมือแก้ไขง่ายๆ

ใครสามารถมีประสบการณ์มากขึ้นในเรื่องนี้ได้โปรดแบ่งปันความคิดเห็นของพวกเขา? สิ่งใดดีสำหรับมือใหม่การเติมข้อความอัตโนมัติหรือการพิมพ์ด้วยตนเอง

ปรับปรุง

ขอบคุณสำหรับการป้อนข้อมูลทุกคน!

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

• เมื่อสร้างวัตถุประเภทรายการ IDE จะเติมข้อความอัตโนมัติให้กับ ArrayList ใหม่ทางด้านขวามือ อาจไม่ชัดเจนสำหรับมือใหม่ในทันทีว่าทำไมมันไม่สามารถเป็น List ใหม่ได้ แต่เฮ้มันใช้ได้ผลดังนั้นพวกเขาจึงเดินหน้าต่อไป
• การกรอกพารามิเตอร์วิธีการขึ้นอยู่กับตัวแปรท้องถิ่นในบริบท
• กำลังทำการคัดลอกวัตถุ
• เพิ่มคำสั่ง 'นำเข้า' หรือ 'ใช้' โดยอัตโนมัติ

และอีกมากมาย นี่คือสิ่งที่ฉันหมายถึง จำไว้ว่าฉันกำลังพูดถึงคนที่กำลังเขียนโปรแกรม 101 จริงๆเพิ่งเริ่มต้น ฉันได้ดู IDE ทำสิ่งเหล่านี้ซึ่งพวกเขาไม่ทราบ แต่พวกเขาก็ดำเนินการต่อไป

อาจมีคนแย้งว่ามันช่วยให้พวกเขามุ่งเน้นไปที่การไหลของโปรแกรมและการเข้าใจสิ่งต่าง ๆ ก่อนที่จะเจาะลึกและเข้าใจความแตกต่างของภาษา แต่ฉันไม่แน่ใจ

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

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

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

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

ในการตอบคำถามที่มีการปรับปรุงส่วน: รายละเอียดไวยากรณ์เล็ก ๆ น้อย ๆ เลย์เอาต์ของไฟล์คอมไพเลอร์และการร้องขอ linker ก็ไม่สำคัญเมื่อเทียบกับแนวคิดการเขียนโปรแกรมทั่วไป เมื่อพวกเขาเข้าใจว่า newbie-no-more สามารถเข้าใจถึงวิธีการทำงานของคนระดับต่ำ มันเป็นการดีที่จะทำเมื่อคุณรู้พื้นฐานแล้วมิฉะนั้นโอกาสที่คุณจะได้รับไสยศาสตร์เวทมนตร์ที่อันตราย

ตัวอย่างเช่น DrScheme IDE มีประวัติที่ยอดเยี่ยมในการสอนการเขียนโปรแกรมและความสำเร็จส่วนใหญ่เกิดจากความสามารถในการให้ความสนใจกับสิ่งที่สำคัญจริงๆ

การใช้การเติมข้อความอัตโนมัติไม่ใช่เรื่องเลวร้ายเลย

มันเป็นเพียงเรื่องความเร็วและสำหรับฉันก็จะเป็นสัญญาณของคนที่เริ่มจับ IDE และใช้งานได้ดี

ฉันไม่เข้าใจว่าการไม่ใช้มันจะช่วยให้พวกเขาเรียนรู้ OO ได้อย่างไร

เมื่อมีการสอนและการติวนักเรียนที่ยังใหม่ต่อการเขียนโปรแกรมฉันพบว่าบางครั้งการเติมข้อความอัตโนมัติ / Intellisense ทำให้เกิดอันตรายมากกว่าดี ใช่พวกเขาสามารถเขียนโปรแกรมโดยใช้มัน ใช่มันรวบรวมและวิ่งและอาจทำสิ่งที่เราขอให้พวกเขาทำ แต่พวกเขาไม่เข้าใจสิ่งที่พวกเขาทำ

เมื่อพวกเขาไม่เข้าใจสิ่งที่เกิดขึ้นมันจะกลายเป็นการเขียนโปรแกรมน้อยลงและแฮ็คโซลูชันร่วมกันเพื่อให้ได้คะแนน ฉันพบว่ามีนักเรียนจำนวนมากเกิดขึ้นเพราะสิ่งที่เราขอให้พวกเขาทำได้ยากขึ้นพวกเขาเพิ่งแฮ็กจนกว่าจะมีบางอย่างทำงานได้ สิ่งนี้ชัดเจนเสมอเมื่อกลางภาคมาและนักเรียนถูกขอให้เขียนวิธีการง่ายๆด้วยมือ ... พวกเขาทำไม่ได้

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

มือใหม่ทำไม่ได้ พวกเขาจะรอ IDE ของพวกเขาดึงรายการวิธีการพวกเขาจะเลื่อนดูรายการนั้นจนกว่าพวกเขาจะพบว่าอาจเป็นสิ่งที่พวกเขาต้องการพวกเขาจะดูพารามิเตอร์ที่ต้องการและดูว่าพวกเขาจะผ่านหรือไม่ .. และในตอนท้ายพวกเขาจะแฮ็กข้อมูลบางอย่างร่วมกันที่พวกเขาสามารถส่งมอบได้

และในตอนท้ายของหลักสูตรเมื่อพวกเขาผ่านพวกเขาจะเดินออกไปจากชั้นเรียนการเขียนโปรแกรมของพวกเขาด้วยชัยชนะตื้น ๆ หลายคนไม่เคยไปเรียนวิชา CS อีกครั้ง b / c พวกเขาไม่เข้าใจสิ่งที่พวกเขาทำหรือทำไมพวกเขาทำ มัน.

ปัญหาเกี่ยวกับ IDEs และสภาพแวดล้อมการพัฒนาโดยทั่วไปนั้นไม่ได้มีอะไรมากมายเช่นการเติมข้อความอัตโนมัติในขณะที่การใช้งานโซลูชัน templated (ไฟล์ | ใหม่ | โครงการ) ซึ่งสิ่งต่าง ๆ ที่ "น่าสนใจ" ได้ถูกทำขึ้นแล้วสำหรับคุณ .

สำหรับคนที่เข้าใจอย่างถ่องแท้ว่าเกิดอะไรขึ้นภายใต้ประทุนนี่จะเป็นประโยชน์ - แต่สำหรับคนที่เรียนรู้สิ่งที่ต้องการน้อยกว่า

นอกจากนี้ยังมีคำถามเกี่ยวกับเวลาที่จะทำให้ IDE รุ่นหนาขึ้น ...

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

แน่นอนว่าเราสามารถสร้างความสับสนให้กับปัญหาได้มากขึ้นโดยพิจารณาจาก Python ที่คุณมีบรรทัดคำสั่ง "live" ...

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

การเรียนรู้วิธีที่ยากลำบากมักจะอยู่กับคุณ

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

ดังนั้นเมื่อไหร่ที่คุณใช้ IDE เมื่อคุณออกแบบบางสิ่งบางอย่างที่ใหญ่โตหรือทำงานบน codebase ขนาดใหญ่ที่มีคลาสวิธีและตัวแปรมากมาย

ฉันจะเป็นคนแรกที่พูดว่า IDEs เป็นประโยชน์ต่อการผลิตแม้ว่าฉันมักจะบ่นเกี่ยวกับนิสัยใจคอของพวกเขา อย่างไรก็ตามฉันเรียนรู้ภาษา BASIC, C, C ++, Java, Python, Perl, PHP และภาษาอื่น ๆ อีกหลายภาษาโดยไม่มีอะไรมากกว่าตัวแก้ไขข้อความที่เน้นและตัวแปลภาษา / ตัวแปลภาษา ฉันเรียนรู้ Java จริง ๆ ใน Notepad!

การเรียนรู้เกี่ยวกับ IDE propmotes "magic" - ความคิดที่ว่า "มันใช้งานได้; สิ่งที่เป็นนามธรรมนั้นดี เวทมนตร์ไม่ดี โปรแกรมเมอร์ควรรู้หรือสามารถค้นพบทุกสิ่งที่เกิดขึ้นในโครงการ IDE ที่ดีได้รับการออกแบบมาเพื่อดูแลการทำบัญชีไม่ใช่การควบคุมโครงการ ใช้อย่างถูกต้องเป็นเครื่องมือที่ดี แต่ช่างฝีมือคนไหนที่เริ่มใช้เราเตอร์ CNC?

ฉันคิดว่าวิธีที่ฉันเรียนรู้ (ต้องพิมพ์ทุกอย่างและรู้คอมไพเลอร์อย่างดีเพื่อสร้างโครงการ) ได้ช่วยฉันอย่างล้นเหลือเมื่อฉันเริ่มใช้ IDE ในที่สุด ตัวอย่างเช่นโปรเจ็กต์ Java ไม่ใช่โฟลเดอร์เล็ก ๆ ในโปรเจ็กต์ Eclipse แต่เป็นการรวบรวมคลาสในโครงสร้างแพ็กเกจที่มีไฟล์ XML บางไฟล์สำหรับพา ธ การกำหนดค่าและการปรับใช้ ฉันไม่ต้องการสร้างแอปพลิเคชันองค์กรขนาดใหญ่หากไม่มี IDE แต่ฉันสามารถสร้างแอปพลิเคชันขนาดเล็กได้ นั่นทำให้ง่ายต่อการเข้าใจโครงสร้างของสิ่งที่มีขนาดใหญ่และเมื่อฉันต้องการพฤติกรรมที่เฉพาะเจาะจงในการสร้างบอกว่าฉันรู้วิธีการทำงานของ javac ดังนั้นฉันจึงสามารถปรับแต่งพร้อมท์การสร้างจริงแทนที่จะพยายามค้นหาชุดวิเศษที่ไม่ได้ ' ไม่มีอยู่ในการกำหนดค่าการสร้าง ฉันยังเชื่อว่าฉันมีความเข้าใจที่ลึกซึ้งขึ้นเกี่ยวกับข้อความแสดงข้อผิดพลาดและวิธีการค้นหาและแก้ไข

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

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

โปรแกรมเมอร์ทุกคนสามารถเรียนรู้ IDE ได้ แต่การรู้ว่า IDE ไม่ได้ทำให้คุณเป็นโปรแกรมเมอร์ที่ดี อารมณ์ขันสีดำกัน "เวทมนตร์" ไม่เคยเป็นคำที่ดีสำหรับโปรแกรมเมอร์ที่จะใช้

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

ช่างฝีมือช่างไม้จะกระโดดลงไปใช้กบพื้นผิวที่มีแรงม้าสูงโดยไม่เข้าใจความสลับซับซ้อนของทั้งไม้และเครื่องบินมือก่อน

(หมายเหตุ: การเติมข้อความอัตโนมัติและ Intellisense เป็นสองสิ่งที่แตกต่างกันอย่างมาก)

Intellisense นั้นไม่เลวเลย มันจะไม่ดีก็ต่อเมื่อใช้ไม้ยันรักแร้เพื่อคาดเดาการทำงานโดยไม่ต้องอ่านหรือทำความเข้าใจกับเอกสารหรือการนำไปปฏิบัติ

จุดด้านข้าง: หากภาษาต้องการ IDE สำหรับโค้ดสำหรับคุณภาษาอาจอยู่ในระดับที่ไม่ถูกต้องของปัญหาที่คุณพยายามแก้ไข

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

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

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

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

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

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

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

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

นอกจากนี้มันไม่เหมือนกับการใช้ IDE หมายความว่าโค้ดจะเขียนเอง นักพัฒนาที่ไม่สมบูรณ์หรือเริ่มต้นจะเขียนโค้ดที่ไม่ทำงานไม่ว่าพวกเขาจะใช้ IDE หรือไม่

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

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

ใน Delphi ฉันสามารถกด ctrl-j และฉันจะเห็นรายการของสิ่งที่เป็นไปได้ทุกอย่างที่ฉันคาดหวังว่าจะได้ผล syntactically

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

IDE ที่ใหม่กว่าช่วยให้ผู้ใช้และนักพัฒนาภาษาใส่ meta-data ไว้ใน intellisense ซึ่งจะช่วยเพิ่มความสามารถในการอ่านและทำความเข้าใจกับฟังก์ชั่นการทำงานโดยไม่ต้องอ่านซอร์ส (ซึ่งเป็นสิ่งที่พวกเขาไม่ควรทำ)

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

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

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

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

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

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

การเรียนรู้ต้องฝึกฝน การเขียนโปรแกรมสามารถเป็นงานที่น่าผิดหวังอย่างมากเมื่อคุณไม่รู้ว่าคุณสามารถทำอะไรได้บ้าง

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

Intellisense มีประโยชน์อย่างมากในการให้ความช่วยเหลือแก่โปรแกรมเมอร์ใหม่ ๆ ที่พวกเขาต้องการเพื่อการเขียนโปรแกรมฝึกการเรียนรู้

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

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

IMO, IDEs จะทำให้คุณทำงานได้มากขึ้น แต่สำหรับผู้เริ่มต้นมักไม่ใช่ความคิดที่ดีในการเริ่มเขียนโปรแกรมด้วย IDE โปรแกรมแก้ไขข้อความเช่น notepad ++, notepad เป็นต้นก็เพียงพอแล้ว

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