คำถามติดแท็ก dynamic-typing

Dynamic Typing เป็นคุณสมบัติของภาษาการเขียนโปรแกรมซึ่งการตรวจสอบประเภทส่วนใหญ่จะดำเนินการในเวลาทำงาน

20
การพิมพ์แบบคงที่คุ้มค่ากับการแลกเปลี่ยนหรือไม่?
ฉันเริ่มเขียนโปรแกรมด้วยภาษา Python เป็นหลักโดยที่ไม่มีความปลอดภัยประเภทจากนั้นย้ายไปที่ C # และ Java ที่มี ฉันพบว่าฉันสามารถทำงานได้เร็วขึ้นและปวดหัวน้อยลงใน Python แต่จากนั้นอีกครั้งแอป C # และ Java ของฉันมีระดับความซับซ้อนที่สูงขึ้นมากดังนั้นฉันจึงไม่เคยให้ Python เป็นการทดสอบความเครียดที่แท้จริง ค่าย Java และ C # ทำให้ดูเหมือนไม่มีความปลอดภัยในสถานที่ที่คนส่วนใหญ่จะทำงานในทุกประเภทของข้อผิดพลาดที่น่ากลัวทิ้งขวาและมันจะมีปัญหามากกว่ามูลค่าของมัน นี่ไม่ใช่การเปรียบเทียบภาษาดังนั้นโปรดอย่าแก้ไขปัญหาเช่นรวบรวมและตีความ ความปลอดภัยของประเภทคุ้มค่าต่อการพัฒนาและความยืดหยุ่นหรือไม่? ทำไม? สำหรับผู้ที่ต้องการตัวอย่างของความคิดเห็นที่การพิมพ์แบบไดนามิกเร็วกว่า: "ใช้ภาษาที่พิมพ์แบบไดนามิกในระหว่างการพัฒนาซึ่งจะช่วยให้คุณได้รับข้อเสนอแนะเวลาตอบสนองและความเร็วในการพัฒนาที่เร็วขึ้น" - http://blog.jayway.com/2010/04/14/static-typing-is-the-root-of-all-evil/

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

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

5
มีความสัมพันธ์ระหว่างขนาดของโครงการและความเข้มงวดของภาษาหรือไม่
การอธิบายถึงความแตกต่างระหว่างความเข้มงวดของภาษาและกระบวนทัศน์ต่อเพื่อนร่วมงานของฉันฉันจึงยืนยันว่า: ภาษาที่ทนทานเช่นภาษาที่มีการเปลี่ยนแปลงและถูกตีความใช้ดีที่สุดสำหรับต้นแบบและโครงการขนาดเล็กหรือเว็บแอปพลิเคชันขนาดกลาง เมื่อเลือกภาษาไดนามิกที่หรูหราเช่น Python หรือ JavaScript ที่มี Node.js ประโยชน์คือ: การพัฒนาที่รวดเร็ว ลดรหัสสำเร็จรูป ความสามารถในการดึงดูดโปรแกรมเมอร์หนุ่มสาวผู้สร้างสรรค์ที่หนี“ ภาษาองค์กร” เช่น Java ภาษาที่พิมพ์ / เรียบเรียงแบบสแตติกเหมาะที่สุดสำหรับแอปพลิเคชันที่ต้องการความเข้มงวดสูงกว่าเช่นแอพที่สำคัญต่อธุรกิจหรือแอพสำหรับแอพขนาดกลางถึงขนาดใหญ่ กระบวนทัศน์และรูปแบบที่รู้จักกันดีพัฒนามานานหลายทศวรรษ ความง่ายในการตรวจสอบแบบคงที่ ความสามารถในการค้นหานักพัฒนามืออาชีพจำนวนมากที่มีประสบการณ์มานานหลายทศวรรษ ภาษาที่เข้มงวดเช่น Haskell, Ada หรือเทคนิคต่าง ๆ เช่นสัญญา Code ใน C # นั้นดีกว่าสำหรับระบบที่ให้ความปลอดภัยมากกว่าความยืดหยุ่น (แม้ว่า Haskell จะมีความยืดหยุ่นสูงมาก) เช่นระบบที่มีความสำคัญต่อชีวิตและระบบซึ่งคาดว่าจะเสถียรมาก ประโยชน์คือ: ความสามารถในการจับข้อบกพร่องให้ได้มากที่สุดในเวลารวบรวม ความง่ายในการตรวจสอบแบบคงที่ ความง่ายในการพิสูจน์อย่างเป็นทางการ อย่างไรก็ตามโดยดูที่ภาษาและเทคโนโลยีที่ใช้สำหรับโครงการขนาดใหญ่โดย บริษัท ขนาดใหญ่, ดูเหมือนว่าการยืนยันของฉันเป็นสิ่งที่ผิด ตัวอย่างเช่น Python ใช้สำหรับระบบขนาดใหญ่เช่น YouTube หรือแอปพลิเคชันอื่น ๆ …

7
การศึกษาภาษาแบบไดนามิกกับแบบคงที่ vs [ปิด]
มีการศึกษาเกี่ยวกับประสิทธิภาพของภาษาที่พิมพ์แบบคงที่และแบบไดนามิกหรือไม่? โดยเฉพาะอย่างยิ่ง: การวัดผลผลิตโปรแกรมเมอร์ อัตราข้อบกพร่อง รวมถึงผลกระทบของการทดสอบหน่วยหรือไม่ ฉันเคยเห็นการถกเถียงกันถึงข้อดีของทั้งสองด้านแล้ว แต่ฉันก็สงสัยว่าใครมีการศึกษาบ้างไหม

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

5
วิธีหลีกเลี่ยง“ ความผิดพลาดทางภาษาแบบไดนามิก” โดยทั่วไปได้อย่างไร?
เมื่อเร็ว ๆ นี้ฉันได้เทจ JavaScript ลงไปสองสามชั่วโมงเพราะฉันต้องการได้รับประโยชน์จากฐานผู้ใช้ขนาดใหญ่ การทำเช่นนั้นฉันได้สังเกตเห็นรูปแบบที่คนส่วนใหญ่ใช้กับภาษาแบบไดนามิก คุณจะได้รับสิ่งที่ทำงานได้อย่างรวดเร็วจริงๆ แต่เมื่อรหัสของคุณถึงขนาดที่กำหนดคุณเสียเวลามากกับการพิมพ์การสะกดและการเปลี่ยนข้อผิดพลาดโดยทั่วไป ข้อผิดพลาดที่คอมไพเลอร์ปกติจะช่วยฉันจาก และไม่ให้ฉันค้นหาข้อผิดพลาดในตรรกะเมื่อฉันทำผิดในโมดูลอื่น การพิจารณาจาวาสคริปต์ต่อไปนี้และภาษาที่พิมพ์แบบไดนามิกอื่น ๆ ทำให้ฉันเชื่อว่ามีบางอย่างผิดปกติกับแนวทางของฉัน หรือนี่เป็นเพียงราคาที่คุณต้องจ่าย? วิธีทำให้รัดกุมยิ่งขึ้น: คุณเข้าใกล้โครงการ JavaScript (หรือภาษาไดนามิกอื่น ๆ สำหรับเรื่องนั้น) ด้วย ~ 2000 LOC อย่างไร มีเครื่องมือในการป้องกันไม่ให้ฉันทำผิดพลาดเหล่านั้นหรือไม่? ฉันลองใช้การไหลผ่าน Facebook และ JSHint ซึ่งค่อนข้างจะช่วยได้ แต่ไม่จับความผิดพลาด

9
ภาษาที่มีการพิมพ์แบบไดนามิกควรได้รับการวิจารณ์หรือไม่? [ปิด]
ฉันได้อ่านบทความบนอินเทอร์เน็ตเกี่ยวกับการเลือกภาษาโปรแกรมในองค์กร เมื่อเร็ว ๆ นี้ภาษาที่พิมพ์แบบไดนามิกจำนวนมากได้รับความนิยมเช่น Ruby, Python, PHP และ Erlang แต่องค์กรจำนวนมากยังคงอยู่กับภาษาที่พิมพ์แบบคงที่เช่น C, C ++, C # และ Java และใช่หนึ่งในประโยชน์ของภาษาที่พิมพ์แบบคงที่คือข้อผิดพลาดการเขียนโปรแกรมที่ถูกจับก่อนหน้านี้ในเวลารวบรวมมากกว่าในเวลาทำงาน แต่ยังมีข้อได้เปรียบกับภาษาที่พิมพ์แบบไดนามิก ( เพิ่มเติมเกี่ยวกับ Wikipedia ) เหตุผลหลักที่องค์กรไม่เริ่มใช้ภาษาอย่าง Erlang, Ruby และ Python ดูเหมือนว่าพวกเขาเป็นแบบไดนามิก นั่นก็เป็นเหตุผลหลักว่าทำไมคนใน StackOverflow ตัดสินใจต่อต้าน Erlang ดูทำไมคุณตัดสินใจ "กับ" Erlang แต่มีดูเหมือนจะเป็นคำวิจารณ์ที่แข็งแกร่งกับพิมพ์แบบไดนามิกในองค์กร แต่ฉันไม่ได้รับมันจริงๆว่าทำไมมันเป็นที่แข็งแกร่ง ทำไมมีการวิพากษ์วิจารณ์อย่างมากต่อการพิมพ์แบบไดนามิกในองค์กร? มันส่งผลกระทบต่อต้นทุนของโครงการมากหรือไม่? แต่บางทีฉันผิด

9
มีรูปแบบการออกแบบที่เป็นไปได้เฉพาะในภาษาที่พิมพ์แบบไดนามิกเช่น Python หรือไม่?
ฉันอ่านคำถามที่เกี่ยวข้องมีรูปแบบการออกแบบใดที่ไม่จำเป็นในภาษาไดนามิกเช่น Python หรือไม่? และจดจำคำพูดนี้บน Wikiquote.org สิ่งมหัศจรรย์เกี่ยวกับการพิมพ์แบบไดนามิกคือช่วยให้คุณสามารถแสดงสิ่งที่คำนวณได้ และประเภทของระบบไม่พิมพ์ - ระบบประเภทมักจะตัดสินใจได้และพวกเขา จำกัด ให้คุณเป็นส่วนย่อย ผู้ที่ชื่นชอบระบบแบบสแตติกพูดว่า“ ใช้ได้เลยมันดีพอ โปรแกรมที่น่าสนใจทั้งหมดที่คุณต้องการเขียนจะใช้งานได้ตามประเภท” แต่นั่นไร้สาระ - เมื่อคุณมีระบบพิมพ์คุณจะไม่รู้ด้วยซ้ำว่าโปรแกรมที่น่าสนใจนั้นมีอะไรบ้าง --- วิทยุวิศวกรรมซอฟต์แวร์ตอนที่ 140: Newspeak และประเภทที่เสียบได้ด้วย Gilad Bracha ฉันสงสัยว่ามีรูปแบบการออกแบบหรือกลยุทธ์ที่มีประโยชน์โดยใช้สูตรของคำพูด "ไม่ทำงานเป็นประเภท" หรือไม่?

3
มีข้อได้เปรียบที่แท้จริงสำหรับภาษาไดนามิกหรือไม่ [ปิด]
ก่อนอื่นฉันอยากจะบอกว่า Java เป็นภาษาเดียวที่ฉันเคยใช้ดังนั้นโปรดขอโทษด้วยที่ฉันไม่รู้เรื่องนี้ ภาษาที่พิมพ์แบบไดนามิกช่วยให้คุณสามารถใส่ค่าใด ๆ ในตัวแปรใด ๆ ตัวอย่างเช่นคุณสามารถเขียนฟังก์ชันต่อไปนี้ (psuedocode): void makeItBark(dog){ dog.bark(); } และคุณสามารถผ่านเข้าไปได้ทุกสิ่ง ตราบใดที่ค่ามีbark()วิธีการรหัสจะทำงาน มิฉะนั้นข้อผิดพลาดรันไทม์หรือสิ่งที่คล้ายกันจะถูกโยน (โปรดแก้ไขฉันหากฉันทำผิดในเรื่องนี้) ดูเหมือนจะทำให้คุณมีความยืดหยุ่น อย่างไรก็ตามฉันได้อ่านเกี่ยวกับภาษาไดนามิกและสิ่งที่คนพูดคือเมื่อออกแบบหรือเขียนโค้ดในภาษาไดนามิกคุณคิดเกี่ยวกับประเภทและนำมาพิจารณาเช่นเดียวกับที่คุณพิมพ์ด้วยภาษาแบบคงที่ ตัวอย่างเช่นเมื่อเขียนmakeItBark()ฟังก์ชันคุณตั้งใจให้ยอมรับเฉพาะสิ่งที่เห่าและคุณยังต้องตรวจสอบให้แน่ใจว่าคุณส่งสิ่งเหล่านี้ลงไปเท่านั้น ข้อแตกต่างคือตอนนี้คอมไพเลอร์จะไม่บอกคุณเมื่อคุณทำผิด แน่นอนว่ามีข้อดีอย่างหนึ่งของวิธีนี้ซึ่งก็คือในภาษาคงที่เพื่อให้บรรลุ 'ฟังก์ชั่นนี้ยอมรับทุกสิ่งที่สามารถเห่า' คุณจะต้องใช้Barkerอินเทอร์เฟซที่ชัดเจน ถึงกระนั้นก็ดูเหมือนว่าจะได้เปรียบเล็กน้อย ฉันพลาดอะไรไปรึเปล่า? ฉันได้อะไรจากการใช้ภาษาที่พิมพ์แบบไดนามิก?

2
คุณลักษณะความหมายของ Python (และภาษาไดนามิกอื่น ๆ ) มีส่วนทำให้ความช้าของมันคืออะไร?
ฉันไม่รู้จัก Python มาก ฉันพยายามที่จะเข้าใจอย่างแม่นยำมากขึ้นว่าคุณลักษณะที่แน่นอนของภาษาแบบไดนามิก (à la Python, Lua, Scheme, Perl, Ruby, .... ) กำลังบังคับให้การใช้งานของพวกเขาช้า ในกรณีนี้ Lua 5.3 เครื่องจักร metatableจะทำให้ Lua ค่อนข้างสังหรณ์ใจ แต่ในทางปฏิบัติ Lua มีข่าวลือว่าค่อนข้างเร็ว (และเร็วกว่า Python) นอกจากนี้ผมมีสัญชาตญาณ (อาจจะผิดอย่างใดอย่างหนึ่ง) ว่าตั้งแต่โปรเซสเซอร์ปัจจุบันหน่วยความจำได้ช้ากว่าการคำนวณดิบ (เข้าถึงหน่วยความจำแคชพลาดความต้องการในเวลาเดียวกันเป็นหลายร้อยดำเนินการทางคณิตศาสตร์), พิมพ์แบบไดนามิกการตรวจสอบ (เมนูif (value->type != INTEGER_TAG) return;ใน C parlance) สามารถวิ่งได้ค่อนข้างเร็ว แน่นอนว่าการวิเคราะห์โปรแกรมทั้งหมด (เช่นการดำเนินการตามโครงการของสตาลิน ) สามารถทำให้การใช้ภาษาแบบไดนามิกเป็นนักแปลทำงานได้อย่างรวดเร็ว แต่ลองทำเป็นว่าฉันไม่มีเวลาออกแบบตัววิเคราะห์โปรแกรมทั้งหมดในตอนแรก (ฉันกำลังออกแบบภาษาไดนามิกในจอภาพ MELTของฉันและบางส่วนจะถูกแปลเป็น C)

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

6
การพิมพ์แบบค่อยเป็นค่อยไป:“ เกือบทุกภาษาที่มีระบบพิมพ์แบบสแตติกยังมีระบบพิมพ์แบบไดนามิก”
การอ้างสิทธิ์โดยAleks Bromfieldระบุว่า: เกือบทุกภาษาที่มีระบบพิมพ์แบบสแตติกก็มีระบบพิมพ์แบบไดนามิกเช่นกัน นอกเหนือจาก C ฉันไม่สามารถคิดถึงข้อยกเว้นได้ นี่คือการอ้างสิทธิ์ที่ถูกต้องหรือไม่ ฉันเข้าใจว่าด้วยคลาส Reflection หรือ Loading ที่รันไทม์ Java จะมีลักษณะเช่นนี้ - แต่สามารถขยายความคิดของ 'การพิมพ์ทีละส่วน' เป็นภาษาจำนวนมากได้หรือไม่?

2
การสร้างคลาสแบบไดนามิกจากชนิดที่ถูกดึงข้อมูลขณะรันไทม์
เป็นไปได้ไหมที่จะทำสิ่งต่อไปนี้ใน C # (หรือในภาษาอื่น ๆ )? ฉันกำลังดึงข้อมูลจากฐานข้อมูล ณ รันไทม์ฉันสามารถคำนวณจำนวนคอลัมน์และชนิดข้อมูลของคอลัมน์ที่ดึงมา ต่อไปฉันต้องการ "สร้าง" คลาสที่มีชนิดข้อมูลเหล่านี้เป็นฟิลด์ ฉันต้องการเก็บบันทึกทั้งหมดที่ฉันได้รับในคอลเลกชัน ปัญหาคือฉันต้องการทำทั้งขั้นตอนที่1และ2ที่ runtime เป็นไปได้ไหม ตอนนี้ฉันใช้ C # แต่ฉันสามารถเปลี่ยนไปใช้อย่างอื่นได้ถ้าต้องการ

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

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.