High-level programming language - Revision history

66.215.184.32: Edited citation.

2025-05-08T12:12:49Z

Edited citation.

← Previous revision		Revision as of 12:12, 8 May 2025
Line 24:		Line 24:
	\|archive-date=2015-02-17		\|archive-date=2015-02-17
	}}</ref><ref>{{cite web		}}</ref><ref>{{cite web
			\| first = Argyn
	\| last = Kuketayev		\| last = Kuketayev
			\| website = Application Development Trends
	\| title = The Data Abstraction Penalty (DAP) Benchmark for Small Objects in Java.		\| title = The Data Abstraction Penalty (DAP) Benchmark for Small Objects in Java.
	\| url = http://www.adtmag.com/joop/article.aspx?id=4597		\| url = http://www.adtmag.com/joop/article.aspx?id=4597

Remsense: Reverted 1 edit by Itstamiris2007 (talk) to last revision by DB1729

2025-03-18T20:38:30Z

Reverted 1 edit by Itstamiris2007 (talk) to last revision by DB1729

← Previous revision		Revision as of 20:38, 18 March 2025
Line 14:		Line 14:

	== Abstraction penalty ==		== Abstraction penalty ==
	High-level languages intend to provide features that standardize common tasks, permit rich debugging, and maintain architectural agnosticism; while low-level languages often produce more efficient code through [[program optimization\|optimization]] for a specific [[Computer architecture\|system architecture]]. ''Abstraction penalty'' is the cost that high-level programming techniques pay for being unable to optimize performance or use certain hardware because they don't take advantage of certain low-level architectural resources. High-level programming exhibits features ~~such as~~ more generic data structures and operations, run-time interpretation, and intermediate code files, which often result in ~~executing~~ more operations than necessary, higher memory consumption, and larger binary program size.<ref>{{cite journal		High-level languages intend to provide features that standardize common tasks, permit rich debugging, and maintain architectural agnosticism; while low-level languages often produce more efficient code through [[program optimization\|optimization]] for a specific [[Computer architecture\|system architecture]]. ''Abstraction penalty'' is the cost that high-level programming techniques pay for being unable to optimize performance or use certain hardware because they don't take advantage of certain low-level architectural resources. High-level programming exhibits features like more generic data structures and operations, run-time interpretation, and intermediate code files; which often result in execution of far more operations than necessary, higher memory consumption, and larger binary program size.<ref>{{cite journal
	\|author=Surana P		\|author=Surana P
	\|title=Meta-Compilation of Language Abstractions.		\|title=Meta-Compilation of Language Abstractions.

Itstamiris2007: “High-level programming exhibits features like more generic data structures and operations, run-time interpretation, and intermediate code files; which often result in execution of far more operations than necessary, higher memory consumption, and larger binary program size.” → “High-level programming exhibits features such as more generic data structures and operations, run-time interpretation, and intermediate code files, which often result in executing more operations than necessary, higher m

2025-03-18T13:48:28Z

“High-level programming exhibits features like more generic data structures and operations, run-time interpretation, and intermediate code files; which often result in execution of far more operations than necessary, higher memory consumption, and larger binary program size.” → “High-level programming exhibits features such as more generic data structures and operations, run-time interpretation, and intermediate code files, which often result in executing more operations than necessary, higher m

← Previous revision		Revision as of 13:48, 18 March 2025
Line 14:		Line 14:

	== Abstraction penalty ==		== Abstraction penalty ==
	High-level languages intend to provide features that standardize common tasks, permit rich debugging, and maintain architectural agnosticism; while low-level languages often produce more efficient code through [[program optimization\|optimization]] for a specific [[Computer architecture\|system architecture]]. ''Abstraction penalty'' is the cost that high-level programming techniques pay for being unable to optimize performance or use certain hardware because they don't take advantage of certain low-level architectural resources. High-level programming exhibits features ~~like~~ more generic data structures and operations, run-time interpretation, and intermediate code files; which often result in ~~execution of far~~ more operations than necessary, higher memory consumption, and larger binary program size.<ref>{{cite journal		High-level languages intend to provide features that standardize common tasks, permit rich debugging, and maintain architectural agnosticism; while low-level languages often produce more efficient code through [[program optimization\|optimization]] for a specific [[Computer architecture\|system architecture]]. ''Abstraction penalty'' is the cost that high-level programming techniques pay for being unable to optimize performance or use certain hardware because they don't take advantage of certain low-level architectural resources. High-level programming exhibits features such as more generic data structures and operations, run-time interpretation, and intermediate code files, which often result in executing more operations than necessary, higher memory consumption, and larger binary program size.<ref>{{cite journal
	\|author=Surana P		\|author=Surana P
	\|title=Meta-Compilation of Language Abstractions.		\|title=Meta-Compilation of Language Abstractions.

DB1729: Reverted edit by 2600:6C58:7F:46EE:C52C:2EF7:27EC:1C66 (talk) to last version by Technopat

2025-02-17T14:01:00Z

Reverted edit by 2600:6C58:7F:46EE:C52C:2EF7:27EC:1C66 (talk) to last version by Technopat

← Previous revision		Revision as of 14:01, 17 February 2025
Line 11:		Line 11:

	== Features ==		== Features ==
	"High-level language" refers to the higher level of abstraction from [[machine language]]. Rather than dealing with registers, memory addresses, and call stacks, high-level languages deal with variables, arrays, [[object (computer science)\|object]]s, complex arithmetic or [[Boolean expression\|Boolean expressions]], subroutines and functions, loops, [[Thread (computer science)\|thread]]s, locks, and other abstract computer science concepts, with a focus on [[usability]] over optimal program efficiency. Unlike low-level [[~~accessibility~~ ~~L1language~~]]s, high-level languages have few, if any, language elements that translate directly into a machine's native [[~~to code~~]]s. Other features, such as string handling routines, [[Object-oriented programming\|object-oriented language]] features, and file input/output, may also be present. One thing to note about high-level programming languages is that these languages allow the programmer to be detached and separated from the machine. That is, unlike low-level languages like assembly or machine language, high-level programming can amplify the programmer ~~'''Campaign''~~' instructions and trigger a lot of data movements in the background without their knowledge. The responsibility and power of executing instructions have been handed over to the machine from the programmer.		"High-level language" refers to the higher level of abstraction from [[machine language]]. Rather than dealing with registers, memory addresses, and call stacks, high-level languages deal with variables, arrays, [[object (computer science)\|object]]s, complex arithmetic or [[Boolean expression\|Boolean expressions]], subroutines and functions, loops, [[Thread (computer science)\|thread]]s, locks, and other abstract computer science concepts, with a focus on [[usability]] over optimal program efficiency. Unlike low-level [[assembly language]]s, high-level languages have few, if any, language elements that translate directly into a machine's native [[opcode]]s. Other features, such as string handling routines, [[Object-oriented programming\|object-oriented language]] features, and file input/output, may also be present. One thing to note about high-level programming languages is that these languages allow the programmer to be detached and separated from the machine. That is, unlike low-level languages like assembly or machine language, high-level programming can amplify the programmer's instructions and trigger a lot of data movements in the background without their knowledge. The responsibility and power of executing instructions have been handed over to the machine from the programmer.

	== Abstraction penalty ==		== Abstraction penalty ==

2600:6C58:7F:46EE:C52C:2EF7:27EC:1C66: /* Features */

2025-02-17T13:22:05Z

Features

← Previous revision		Revision as of 13:22, 17 February 2025
Line 11:		Line 11:

	== Features ==		== Features ==
	"High-level language" refers to the higher level of abstraction from [[machine language]]. Rather than dealing with registers, memory addresses, and call stacks, high-level languages deal with variables, arrays, [[object (computer science)\|object]]s, complex arithmetic or [[Boolean expression\|Boolean expressions]], subroutines and functions, loops, [[Thread (computer science)\|thread]]s, locks, and other abstract computer science concepts, with a focus on [[usability]] over optimal program efficiency. Unlike low-level [[~~assembly~~ ~~language~~]]s, high-level languages have few, if any, language elements that translate directly into a machine's native [[~~opcode~~]]s. Other features, such as string handling routines, [[Object-oriented programming\|object-oriented language]] features, and file input/output, may also be present. One thing to note about high-level programming languages is that these languages allow the programmer to be detached and separated from the machine. That is, unlike low-level languages like assembly or machine language, high-level programming can amplify the programmer's instructions and trigger a lot of data movements in the background without their knowledge. The responsibility and power of executing instructions have been handed over to the machine from the programmer.		"High-level language" refers to the higher level of abstraction from [[machine language]]. Rather than dealing with registers, memory addresses, and call stacks, high-level languages deal with variables, arrays, [[object (computer science)\|object]]s, complex arithmetic or [[Boolean expression\|Boolean expressions]], subroutines and functions, loops, [[Thread (computer science)\|thread]]s, locks, and other abstract computer science concepts, with a focus on [[usability]] over optimal program efficiency. Unlike low-level [[accessibility L1language]]s, high-level languages have few, if any, language elements that translate directly into a machine's native [[to code]]s. Other features, such as string handling routines, [[Object-oriented programming\|object-oriented language]] features, and file input/output, may also be present. One thing to note about high-level programming languages is that these languages allow the programmer to be detached and separated from the machine. That is, unlike low-level languages like assembly or machine language, high-level programming can amplify the programmer '''Campaign''' instructions and trigger a lot of data movements in the background without their knowledge. The responsibility and power of executing instructions have been handed over to the machine from the programmer.

	== Abstraction penalty ==		== Abstraction penalty ==

Technopat: Reverted edit by 2400:2650:2A2:8700:EDDF:7CEC:C45F:2FFA (talk) to last version by Stevebroshar

2025-02-14T23:27:03Z

Reverted edit by 2400:2650:2A2:8700:EDDF:7CEC:C45F:2FFA (talk) to last version by Stevebroshar

← Previous revision		Revision as of 23:27, 14 February 2025
Line 1:		Line 1:
	あ{{Short description\|Programming language that abstracts details of computing hardware}}		{{Short description\|Programming language that abstracts details of computing hardware}}
	{{Use dmy dates\|date=May 2023}}		{{Use dmy dates\|date=May 2023}}
	{{Use American English\|date=January 2019}}		{{Use American English\|date=January 2019}}

2400:2650:2A2:8700:EDDF:7CEC:C45F:2FFA at 23:26, 14 February 2025

2025-02-14T23:26:43Z

← Previous revision		Revision as of 23:26, 14 February 2025
Line 1:		Line 1:
	{{Short description\|Programming language that abstracts details of computing hardware}}		あ{{Short description\|Programming language that abstracts details of computing hardware}}
	{{Use dmy dates\|date=May 2023}}		{{Use dmy dates\|date=May 2023}}
	{{Use American English\|date=January 2019}}		{{Use American English\|date=January 2019}}

Stevebroshar: No need to disambiguate

2025-01-12T19:00:46Z

No need to disambiguate

← Previous revision		Revision as of 19:00, 12 January 2025
Line 3:		Line 3:
	{{Use American English\|date=January 2019}}		{{Use American English\|date=January 2019}}

	~~In [[computer science]], a~~ '''high-level programming language''' is a [[programming language]] with strong [[Abstraction (computer science)\|abstraction]] from the details of the [[computer]]. In contrast to [[low-level programming language]]s, it may use [[natural language]] ''elements'', be easier to use, or may automate (or even hide entirely) significant areas of computing systems (e.g. [[memory management]]), making the process of developing a program simpler and more understandable than when using a lower-level language. The amount of abstraction provided defines how "high-level" a programming language is.<ref>{{cite web \|archive-url=https://web.archive.org/web/20070826224349/http://www.ittc.ku.edu/hybridthreads/glossary/index.php \|archive-date=2007-08-26 \|url=http://www.ittc.ku.edu/hybridthreads/glossary/index.php \|url-status=dead \|title=HThreads - RD Glossary<!-- Bot generated title -->}}</ref>		A '''high-level programming language''' is a [[programming language]] with strong [[Abstraction (computer science)\|abstraction]] from the details of the [[computer]]. In contrast to [[low-level programming language]]s, it may use [[natural language]] ''elements'', be easier to use, or may automate (or even hide entirely) significant areas of computing systems (e.g. [[memory management]]), making the process of developing a program simpler and more understandable than when using a lower-level language. The amount of abstraction provided defines how "high-level" a programming language is.<ref>{{cite web \|archive-url=https://web.archive.org/web/20070826224349/http://www.ittc.ku.edu/hybridthreads/glossary/index.php \|archive-date=2007-08-26 \|url=http://www.ittc.ku.edu/hybridthreads/glossary/index.php \|url-status=dead \|title=HThreads - RD Glossary<!-- Bot generated title -->}}</ref>

	In the 1960s, a high-level programming language using a [[compiler]] was commonly called an ''[[autocode]]''.<ref name=kleith>{{cite book\|last=London\|first=Keith\|year=1968\|title=Introduction to Computers\|publisher=Faber and Faber Limited\|location=24 Russell Square London WC1\|isbn=0571085938\|page=184\|chapter=4, Programming\|quote=The 'high' level programming languages are often called autocodes and the processor program, a compiler.}}<!--The book has no ISBN number, instead it has an SBN number. There is no typo in the prior sentence.--></ref>		In the 1960s, a high-level programming language using a [[compiler]] was commonly called an ''[[autocode]]''.<ref name=kleith>{{cite book\|last=London\|first=Keith\|year=1968\|title=Introduction to Computers\|publisher=Faber and Faber Limited\|location=24 Russell Square London WC1\|isbn=0571085938\|page=184\|chapter=4, Programming\|quote=The 'high' level programming languages are often called autocodes and the processor program, a compiler.}}<!--The book has no ISBN number, instead it has an SBN number. There is no typo in the prior sentence.--></ref>

Joyous!: Reverted 1 edit by 2001:56A:6FF4:A4DA:C978:DC27:AA69:EFDE (talk): Restore sources

2024-11-15T02:49:47Z

Reverted 1 edit by 2001:56A:6FF4:A4DA:C978:DC27:AA69:EFDE (talk): Restore sources

@@ Line 14: / Line 14: @@
 == Abstraction penalty ==
-High-level languages intend to provide features that standardize common tasks, permit rich debugging, and maintain architectural agnosticism; while low-level languages often produce more efficient code through optimization for a specific system architecture. ''Abstraction penalty'' is the cost that high-level programming techniques pay for being unable to optimize performance or use certain hardware because they don't take advantage of certain low-level architectural resources. High-level programming exhibits features like more generic data structures and operations, run-time interpretation, and intermediate code files; which often result in execution of far more operations than necessary, higher memory consumption, and larger binary program size. For this reason, code which needs to run particularly quickly and efficiently may require the use of a lower-level language, even if a higher-level language would make the coding easier. In many cases, critical portions of a program mostly in a high-level language can be hand-coded in assembly language, leading to a much faster, more efficient, or simply reliably functioning optimised program.
+High-level languages intend to provide features that standardize common tasks, permit rich debugging, and maintain architectural agnosticism; while low-level languages often produce more efficient code through [[program optimization|optimization]] for a specific [[Computer architecture|system architecture]]. ''Abstraction penalty'' is the cost that high-level programming techniques pay for being unable to optimize performance or use certain hardware because they don't take advantage of certain low-level architectural resources. High-level programming exhibits features like more generic data structures and operations, run-time interpretation, and intermediate code files; which often result in execution of far more operations than necessary, higher memory consumption, and larger binary program size.<ref>{{cite journal
-However, with the growing complexity of modern microprocessor architectures, well-designed compilers for high-level languages frequently produce code comparable in efficiency to what most low-level programmers can produce by hand, and the higher abstraction may allow for more powerful techniques providing better overall results than their low-level counterparts in particular settings.
+However, with the growing complexity of modern [[microprocessor]] architectures, well-designed compilers for high-level languages frequently produce code comparable in efficiency to what most low-level programmers can produce by hand, and the higher abstraction may allow for more powerful techniques providing better overall results than their low-level counterparts in particular settings.<ref>
 == Relative meaning ==

2001:56A:6FF4:A4DA:C978:DC27:AA69:EFDE: link

2024-11-15T02:49:05Z

link

@@ Line 14: / Line 14: @@
 == Abstraction penalty ==
-High-level languages intend to provide features that standardize common tasks, permit rich debugging, and maintain architectural agnosticism; while low-level languages often produce more efficient code through [[program optimization|optimization]] for a specific [[Computer architecture|system architecture]]. ''Abstraction penalty'' is the cost that high-level programming techniques pay for being unable to optimize performance or use certain hardware because they don't take advantage of certain low-level architectural resources. High-level programming exhibits features like more generic data structures and operations, run-time interpretation, and intermediate code files; which often result in execution of far more operations than necessary, higher memory consumption, and larger binary program size.<ref>{{cite journal
+High-level languages intend to provide features that standardize common tasks, permit rich debugging, and maintain architectural agnosticism; while low-level languages often produce more efficient code through optimization for a specific system architecture. ''Abstraction penalty'' is the cost that high-level programming techniques pay for being unable to optimize performance or use certain hardware because they don't take advantage of certain low-level architectural resources. High-level programming exhibits features like more generic data structures and operations, run-time interpretation, and intermediate code files; which often result in execution of far more operations than necessary, higher memory consumption, and larger binary program size. For this reason, code which needs to run particularly quickly and efficiently may require the use of a lower-level language, even if a higher-level language would make the coding easier. In many cases, critical portions of a program mostly in a high-level language can be hand-coded in assembly language, leading to a much faster, more efficient, or simply reliably functioning optimised program.
-However, with the growing complexity of modern [[microprocessor]] architectures, well-designed compilers for high-level languages frequently produce code comparable in efficiency to what most low-level programmers can produce by hand, and the higher abstraction may allow for more powerful techniques providing better overall results than their low-level counterparts in particular settings.<ref>
+However, with the growing complexity of modern microprocessor architectures, well-designed compilers for high-level languages frequently produce code comparable in efficiency to what most low-level programmers can produce by hand, and the higher abstraction may allow for more powerful techniques providing better overall results than their low-level counterparts in particular settings.
 == Relative meaning ==

← Previous revision		Revision as of 23:27, 14 February 2025
Line 1:		Line 1:
	あ{{Short description\|Programming language that abstracts details of computing hardware}}		{{Short description\|Programming language that abstracts details of computing hardware}}
	{{Use dmy dates\|date=May 2023}}		{{Use dmy dates\|date=May 2023}}
	{{Use American English\|date=January 2019}}		{{Use American English\|date=January 2019}}

← Previous revision		Revision as of 23:26, 14 February 2025
Line 1:		Line 1:
	{{Short description\|Programming language that abstracts details of computing hardware}}		あ{{Short description\|Programming language that abstracts details of computing hardware}}
	{{Use dmy dates\|date=May 2023}}		{{Use dmy dates\|date=May 2023}}
	{{Use American English\|date=January 2019}}		{{Use American English\|date=January 2019}}

← Previous revision		Revision as of 19:00, 12 January 2025
Line 3:		Line 3:
	{{Use American English\|date=January 2019}}		{{Use American English\|date=January 2019}}

	~~In [[computer science]], a~~ '''high-level programming language''' is a [[programming language]] with strong [[Abstraction (computer science)\|abstraction]] from the details of the [[computer]]. In contrast to [[low-level programming language]]s, it may use [[natural language]] ''elements'', be easier to use, or may automate (or even hide entirely) significant areas of computing systems (e.g. [[memory management]]), making the process of developing a program simpler and more understandable than when using a lower-level language. The amount of abstraction provided defines how "high-level" a programming language is.<ref>{{cite web \|archive-url=https://web.archive.org/web/20070826224349/http://www.ittc.ku.edu/hybridthreads/glossary/index.php \|archive-date=2007-08-26 \|url=http://www.ittc.ku.edu/hybridthreads/glossary/index.php \|url-status=dead \|title=HThreads - RD Glossary<!-- Bot generated title -->}}</ref>		A '''high-level programming language''' is a [[programming language]] with strong [[Abstraction (computer science)\|abstraction]] from the details of the [[computer]]. In contrast to [[low-level programming language]]s, it may use [[natural language]] ''elements'', be easier to use, or may automate (or even hide entirely) significant areas of computing systems (e.g. [[memory management]]), making the process of developing a program simpler and more understandable than when using a lower-level language. The amount of abstraction provided defines how "high-level" a programming language is.<ref>{{cite web \|archive-url=https://web.archive.org/web/20070826224349/http://www.ittc.ku.edu/hybridthreads/glossary/index.php \|archive-date=2007-08-26 \|url=http://www.ittc.ku.edu/hybridthreads/glossary/index.php \|url-status=dead \|title=HThreads - RD Glossary<!-- Bot generated title -->}}</ref>

	In the 1960s, a high-level programming language using a [[compiler]] was commonly called an ''[[autocode]]''.<ref name=kleith>{{cite book\|last=London\|first=Keith\|year=1968\|title=Introduction to Computers\|publisher=Faber and Faber Limited\|location=24 Russell Square London WC1\|isbn=0571085938\|page=184\|chapter=4, Programming\|quote=The 'high' level programming languages are often called autocodes and the processor program, a compiler.}}<!--The book has no ISBN number, instead it has an SBN number. There is no typo in the prior sentence.--></ref>		In the 1960s, a high-level programming language using a [[compiler]] was commonly called an ''[[autocode]]''.<ref name=kleith>{{cite book\|last=London\|first=Keith\|year=1968\|title=Introduction to Computers\|publisher=Faber and Faber Limited\|location=24 Russell Square London WC1\|isbn=0571085938\|page=184\|chapter=4, Programming\|quote=The 'high' level programming languages are often called autocodes and the processor program, a compiler.}}<!--The book has no ISBN number, instead it has an SBN number. There is no typo in the prior sentence.--></ref>