Stack-oriented programming - Revision history

LVDP01: Rewriting lead

2024-12-26T20:55:27Z

Rewriting lead

← Previous revision		Revision as of 20:55, 26 December 2024
Line 5:		Line 5:
	{{tone\|date=March 2019}}}}		{{tone\|date=March 2019}}}}

	'''Stack-oriented programming''' is a [[programming paradigm]] that relies on a ~~stack (~~or ~~multiple~~ stacks) to manipulate [[data]] and/or pass parameters. Several [[Programming language\|programming languages]] fit this description, notably [[Forth (programming language)\|Forth]], [[RPL (programming language)\|RPL]], and [[PostScript]]. Stack-oriented programming languages operate on one or more [[Stack (data structure)\|stacks]], each of which may serve a different purpose. Programming constructs in other programming languages need to be modified for use in a stack-oriented system.<ref>Luerweg, T. (2015). Stack based programming paradigms. Concepts of Programming Languages–CoPL’15, 33.</ref> Most stack-oriented languages operate in ''postfix'' or [[Reverse Polish notation]]~~. Any~~ arguments or parameters for a command are ~~stated~~ before that command. For example, postfix notation would be written {{nowrap\|<code>2, 3, multiply</code>}} instead of {{nowrap\|<code>multiply, 2, 3</code>}} (''prefix'' or [[Polish notation]]), or {{nowrap\|<code>2 multiply 3</code>}} ([[infix notation\|''infix'' notation]]). The programming languages [[Forth (programming language)\|Forth]], [[Factor (programming language)\|Factor]], [[RPL (programming language)\|RPL]], [[PostScript]], [[BibTeX]] style design language<ref>{{citation\|author=Oren Patashnik \|title=Designing BibTeX styles \|url=http://www.ctan.org/tex-archive/info/biblio/bibtex/contrib/doc/btxhak.pdf}}{{dead link\|date=April 2019}}</ref> and many [[assembly language]]s fit this paradigm.		'''Stack-oriented programming''' is a [[programming paradigm]] that relies on one or more [[stack machine\|stacks]] to manipulate [[data]] and/or pass parameters. Programming constructs in other programming languages need to be modified for use in a stack-oriented system.<ref>Luerweg, T. (2015). Stack based programming paradigms. Concepts of Programming Languages–CoPL’15, 33.</ref> Most stack-oriented languages operate in ''postfix'' or [[Reverse Polish notation]]: arguments or parameters for a command are listed before that command. For example, postfix notation would be written {{nowrap\|<code>2, 3, multiply</code>}} instead of {{nowrap\|<code>multiply, 2, 3</code>}} (''prefix'' or [[Polish notation]]), or {{nowrap\|<code>2 multiply 3</code>}} ([[infix notation\|''infix'' notation]]). The programming languages [[Forth (programming language)\|Forth]], [[Factor (programming language)\|Factor]], [[RPL (programming language)\|RPL]], [[PostScript]], [[BibTeX]] style design language<ref>{{citation\|author=Oren Patashnik \|title=Designing BibTeX styles \|url=http://www.ctan.org/tex-archive/info/biblio/bibtex/contrib/doc/btxhak.pdf}}{{dead link\|date=April 2019}}</ref> and many [[assembly language]]s fit this paradigm.

	Stack-based algorithms manipulate data by popping data from ~~the stack~~ and pushing data to the stack. ~~Stack manipulation operators~~ govern how the stack manipulates [[data]]. To emphasize the effect of a statement, a comment is often used showing the top of the stack before and after the statement. ~~This~~ is known as the stack effect diagram. ~~PostScript~~ ~~uses~~ ~~separate~~ stacks for ~~additional~~ purposes, ~~including~~ variables, dictionaries, procedures, some typical procedures, and control flow statements. Analysis of the [[language model]] allows expressions and programs to be interpreted simply.		Stack-based algorithms manipulate data by popping data from and pushing data to the stack. Operators govern how the stack manipulates [[data]]. To emphasize the effect of a statement, a comment is often used showing the top of the stack before and after the statement; this is known as the stack effect diagram. Some stack-oriented languages may use multiple stacks for different purposes; for example, PostScript uses separate stacks for variables, dictionaries, procedures, some typical procedures, and control flow statements. Analysis of the [[language model]] allows expressions and programs to be interpreted simply.

	== Stack-based algorithms ==		== Stack-based algorithms ==

Orozon64: Fixed first letter in a sentence not being capitalized.

2024-12-09T18:40:30Z

Fixed first letter in a sentence not being capitalized.

← Previous revision		Revision as of 18:40, 9 December 2024
Line 12:		Line 12:
	PostScript is an example of a postfix stack-based language. An expression example in this language is {{nowrap\|<code>2 3 mul</code>}}('mul' being the command for the multiplication operation). Calculating the expression involves understanding how stack orientation works.		PostScript is an example of a postfix stack-based language. An expression example in this language is {{nowrap\|<code>2 3 mul</code>}}('mul' being the command for the multiplication operation). Calculating the expression involves understanding how stack orientation works.

	Stack orientation can be presented as the following conveyor belt analogy. at the end of a conveyor belt (the ''input''), plates marked <code>2</code>, <code>3</code>, and <code>mul</code> are placed in sequence. The plate at the end of the conveyor (<code>2</code>) can be taken, however other plates cannot be accessed until the plate at the end is removed. The plates can only be stored in a stack, and can only be added or removed from atop the stack, not from the middle or bottom. Blank plates (and a marker) can be supplied and plates can be permanently discarded.		Stack orientation can be presented as the following conveyor belt analogy. At the end of a conveyor belt (the ''input''), plates marked <code>2</code>, <code>3</code>, and <code>mul</code> are placed in sequence. The plate at the end of the conveyor (<code>2</code>) can be taken, however other plates cannot be accessed until the plate at the end is removed. The plates can only be stored in a stack, and can only be added or removed from atop the stack, not from the middle or bottom. Blank plates (and a marker) can be supplied and plates can be permanently discarded.

	[[File:Human stack.svg\|220px]]		[[File:Human stack.svg\|220px]]

Ctsan10: Added links, shortened long sentences

2024-08-11T17:20:56Z

Added links, shortened long sentences

← Previous revision		Revision as of 17:20, 11 August 2024
Line 5:		Line 5:
	{{tone\|date=March 2019}}}}		{{tone\|date=March 2019}}}}

	'''Stack-oriented programming''' is a [[programming paradigm]] that relies on a stack (or multiple stacks) to manipulate data and/or pass parameters. Several programming languages fit this description, notably [[Forth (programming language)\|Forth]], [[RPL (programming language)\|RPL]], and [[PostScript]]. Stack-oriented programming languages operate on one or more [[Stack (data structure)\|stacks]], each of which may serve a different purpose. Programming constructs in other programming languages need to be modified for use in a stack-oriented system.<ref>Luerweg, T. (2015). Stack based programming paradigms. Concepts of Programming Languages–CoPL’15, 33.</ref> Most stack-oriented languages operate in ''postfix'' or [[Reverse Polish notation]]. Any arguments or parameters for a command are stated ''before'' that command. For example, postfix notation would be written {{nowrap\|<code>2, 3, multiply</code>}} instead of {{nowrap\|<code>multiply, 2, 3</code>}} (''prefix'' or [[Polish notation]]), or {{nowrap\|<code>2 multiply 3</code>}} ([[infix notation\|''infix'' notation]]). The programming languages [[Forth (programming language)\|Forth]], [[Factor (programming language)\|Factor]], [[RPL (programming language)\|RPL]], [[PostScript]], [[BibTeX]] style design language<ref>{{citation\|author=Oren Patashnik \|title=Designing BibTeX styles \|url=http://www.ctan.org/tex-archive/info/biblio/bibtex/contrib/doc/btxhak.pdf}}{{dead link\|date=April 2019}}</ref> and many [[assembly language]]s fit this paradigm.		'''Stack-oriented programming''' is a [[programming paradigm]] that relies on a stack (or multiple stacks) to manipulate [[data]] and/or pass parameters. Several [[Programming language\|programming languages]] fit this description, notably [[Forth (programming language)\|Forth]], [[RPL (programming language)\|RPL]], and [[PostScript]]. Stack-oriented programming languages operate on one or more [[Stack (data structure)\|stacks]], each of which may serve a different purpose. Programming constructs in other programming languages need to be modified for use in a stack-oriented system.<ref>Luerweg, T. (2015). Stack based programming paradigms. Concepts of Programming Languages–CoPL’15, 33.</ref> Most stack-oriented languages operate in ''postfix'' or [[Reverse Polish notation]]. Any arguments or parameters for a command are stated before that command. For example, postfix notation would be written {{nowrap\|<code>2, 3, multiply</code>}} instead of {{nowrap\|<code>multiply, 2, 3</code>}} (''prefix'' or [[Polish notation]]), or {{nowrap\|<code>2 multiply 3</code>}} ([[infix notation\|''infix'' notation]]). The programming languages [[Forth (programming language)\|Forth]], [[Factor (programming language)\|Factor]], [[RPL (programming language)\|RPL]], [[PostScript]], [[BibTeX]] style design language<ref>{{citation\|author=Oren Patashnik \|title=Designing BibTeX styles \|url=http://www.ctan.org/tex-archive/info/biblio/bibtex/contrib/doc/btxhak.pdf}}{{dead link\|date=April 2019}}</ref> and many [[assembly language]]s fit this paradigm.

	Stack-based algorithms manipulate data by popping data from the stack and pushing data to the stack. Stack manipulation operators govern how the stack manipulates [[data]]. To emphasize the effect of a statement, a comment is often used showing the top of the stack before and after the statement. This is known as the stack effect diagram. PostScript uses separate stacks for additional purposes, including variables, dictionaries, procedures, some typical procedures, and control flow statements. Analysis of the [[language model]] allows expressions and programs to be interpreted simply.		Stack-based algorithms manipulate data by popping data from the stack and pushing data to the stack. Stack manipulation operators govern how the stack manipulates [[data]]. To emphasize the effect of a statement, a comment is often used showing the top of the stack before and after the statement. This is known as the stack effect diagram. PostScript uses separate stacks for additional purposes, including variables, dictionaries, procedures, some typical procedures, and control flow statements. Analysis of the [[language model]] allows expressions and programs to be interpreted simply.

	== Stack-based algorithms ==		== Stack-based algorithms ==
	PostScript is an example of a postfix stack-based language. An expression example in this language is {{nowrap\|<code>2 3 mul</code>}}('mul' being the command for the multiplication operation). Calculating the expression involves understanding how stack-orientation works.		PostScript is an example of a postfix stack-based language. An expression example in this language is {{nowrap\|<code>2 3 mul</code>}}('mul' being the command for the multiplication operation). Calculating the expression involves understanding how stack orientation works.

	Stack-orientation can be presented as the following conveyor belt analogy. at the end of a conveyor belt (the ''input''), plates marked <code>2</code>, <code>3</code>, and <code>mul</code> are placed in sequence. The plate at the end of the conveyor (<code>2</code>) can be taken, however other plates cannot be accessed until the plate at the end is removed. The plates can only be stored in a stack, and can only be added or removed from atop the stack, not from the middle or bottom. Blank plates (and a marker) can be supplied and plates can be permanently discarded.		Stack orientation can be presented as the following conveyor belt analogy. at the end of a conveyor belt (the ''input''), plates marked <code>2</code>, <code>3</code>, and <code>mul</code> are placed in sequence. The plate at the end of the conveyor (<code>2</code>) can be taken, however other plates cannot be accessed until the plate at the end is removed. The plates can only be stored in a stack, and can only be added or removed from atop the stack, not from the middle or bottom. Blank plates (and a marker) can be supplied and plates can be permanently discarded.

	[[File:Human stack.svg\|220px]]		[[File:Human stack.svg\|220px]]
Line 48:		Line 48:

	== Stack effect diagrams ==		== Stack effect diagrams ==
	As an aid to understanding the effect of statement, a short comment is used showing the top of the stack before and after the statement. The top of the stack is rightmost if there are multiple items. This notation is commonly used in the Forth language, where comments are enclosed in parentheses.		As an aid to understanding the effect of the statement, a short comment is used showing the top of the stack before and after the statement. The top of the stack is rightmost if there are multiple items. This notation is commonly used in the Forth language, where comments are enclosed in parentheses.

	<syntaxhighlight lang="forth">( before -- after )</syntaxhighlight>		<syntaxhighlight lang="forth">( before -- after )</syntaxhighlight>
Line 62:		Line 62:
	</syntaxhighlight>		</syntaxhighlight>

	~~And the~~ <code>fib</code> function below is described:		The <code>fib</code> function below is described:

	<syntaxhighlight lang="forth">fib ( n -- n' )</syntaxhighlight>		<syntaxhighlight lang="forth">fib ( n -- n' )</syntaxhighlight>

	It is equivalent to [[precondition]]s and [[postcondition]]s in [[Hoare logic]]. Both comments may also be referenced as [[assertion (computing)\|assertions]], though not necessarily in context of Stack-based languages.		It is equivalent to [[precondition]]s and [[postcondition]]s in [[Hoare logic]]. Both comments may also be referenced as [[assertion (computing)\|assertions]], though not necessarily in the context of Stack-based languages.

	== PostScript stacks ==		== PostScript stacks ==
Line 72:		Line 72:

	=== Variables and dictionaries ===		=== Variables and dictionaries ===
	The evaluation of different expressions has already been analysed. The implementation of variables is important for any programming language, but for stack-oriented languages it is of special concern, as there is only one way to interact with data.		The evaluation of different expressions has already been analysed. The implementation of variables is important for any programming language, but for stack-oriented languages, it is of special concern, as there is only one way to interact with data.

	The way variables are implemented in stack-oriented languages such as PostScript usually involves a separate, specialized stack which holds ''dictionaries'' of [[key–value pair]]s. To create a variable, a key (the variable name) must be created first, with which a value is then associated. In PostScript, a name data object is prefixed with a <code>/</code>, so <code>/x</code> is a name data object which can be associated with, for example, the number <code>42</code>. The <code>define</code> command is <code>def</code>, so		The way variables are implemented in stack-oriented languages such as PostScript usually involves a separate, specialized stack which holds ''dictionaries'' of [[key–value pair\|key-value pair]]s. To create a variable, a key (the variable name) must be created first, with which a value is then associated. In PostScript, a name data object is prefixed with a <code>/</code>, so <code>/x</code> is a name data object which can be associated with, for example, the number <code>42</code>. The <code>define</code> command is <code>def</code>, so

	<code>/x 42 def</code>		<code>/x 42 def</code>

	associates with the name <code>x</code> with the number <code>42</code> in the dictionary atop the stack. A difference exists between <code>/x</code> and <code>x</code> – the former is a data object representing a name, <code>x</code> stands for what is defined under <code>/x</code>.		associates with the name <code>x</code> with the number <code>42</code> in the dictionary atop the stack. A difference exists between <code>/x</code> and <code>x</code> – the former is a data object representing a name, and <code>x</code> stands for what is defined under <code>/x</code>.

	=== Procedures ===		=== Procedures ===
Line 91:		Line 91:
	Since procedures are treated as simple data objects, names with procedures can be defined. When they are retrieved, they are executed directly.		Since procedures are treated as simple data objects, names with procedures can be defined. When they are retrieved, they are executed directly.

	Dictionaries provide a means of controlling scoping, as well as storing of definitions.		Dictionaries provide a means of controlling scoping, as well as storing definitions.

	Since data objects are stored in the top-most dictionary, an unexpected ability arises naturally: when looking up a definition from a dictionary, the topmost dictionary is checked, then the next, and so on. If a procedure is defined that has the same name as another already defined in a different dictionary, the local one will be called.		Since data objects are stored in the top-most dictionary, an unexpected ability arises naturally: when looking up a definition from a dictionary, the topmost dictionary is checked, then the next, and so on. If a procedure is defined that has the same name as another already defined in a different dictionary, the local one will be called.
Line 179:		Line 179:

	== Analysis of the language model ==		== Analysis of the language model ==
	The simple model provided in a stack-oriented language allows expressions and programs to be interpreted simply and theoretically evaluated much faster, since no [[syntax analysis]] ~~need~~ be done but [[lexical analysis]]. The way such programs are written facilitates being interpreted by machines, which is why PostScript suits printers well for its use. However, the slightly artificial way of writing PostScript programs can form an initial barrier to understanding stack-oriented languages such as PostScript.		The simple model provided in a stack-oriented language allows expressions and programs to be interpreted simply and theoretically evaluated much faster, since no [[syntax analysis]] needs to be done but [[lexical analysis]]. The way such programs are written facilitates being interpreted by machines, which is why PostScript suits printers well for its use. However, the slightly artificial way of writing PostScript programs can form an initial barrier to understanding stack-oriented languages such as PostScript.

	While the ability to shadow by [[method overriding\|overriding]] inbuilt and other definitions can make programs hard to debug, and irresponsible use of this feature can cause unpredictable behaviour, it can simplify some functions greatly. For example, in PostScript use, the <code>~~showpage~~</code> operator can be overridden with a custom one that applies a certain style to the page, instead of having to define a custom operator or to repeat code to generate the style.		While the ability to shadow by [[method overriding\|overriding]] inbuilt and other definitions can make programs hard to debug, and irresponsible use of this feature can cause unpredictable behaviour, it can simplify some functions greatly. For example, in PostScript use, the <code>show page</code> operator can be overridden with a custom one that applies a certain style to the page, instead of having to define a custom operator or repeat code to generate the style.

	== See also ==		== See also ==

Ragz194 at 07:22, 25 June 2024

2024-06-25T07:22:47Z

← Previous revision		Revision as of 07:22, 25 June 2024
Line 179:		Line 179:

	== Analysis of the language model ==		== Analysis of the language model ==
	The simple model provided in a stack-oriented language allows expressions and programs to be interpreted simply and theoretically evaluated much faster, since no [[syntax analysis]] need be done, ~~only~~ [[lexical analysis]]. The way such programs are written facilitates being interpreted by machines, which is why PostScript suits printers well for its use. However, the slightly artificial way of writing PostScript programs can form an initial barrier to understanding stack-oriented languages such as PostScript.		The simple model provided in a stack-oriented language allows expressions and programs to be interpreted simply and theoretically evaluated much faster, since no [[syntax analysis]] need be done but [[lexical analysis]]. The way such programs are written facilitates being interpreted by machines, which is why PostScript suits printers well for its use. However, the slightly artificial way of writing PostScript programs can form an initial barrier to understanding stack-oriented languages such as PostScript.

	While the ability to shadow by [[method overriding\|overriding]] inbuilt and other definitions can make programs hard to debug, and irresponsible use of this feature can cause unpredictable behaviour, it can simplify some functions greatly. For example, in PostScript use, the <code>showpage</code> operator can be overridden with a custom one that applies a certain style to the page, instead of having to define a custom operator or to repeat code to generate the style.		While the ability to shadow by [[method overriding\|overriding]] inbuilt and other definitions can make programs hard to debug, and irresponsible use of this feature can cause unpredictable behaviour, it can simplify some functions greatly. For example, in PostScript use, the <code>showpage</code> operator can be overridden with a custom one that applies a certain style to the page, instead of having to define a custom operator or to repeat code to generate the style.

LVDP01 at 10:33, 17 June 2024

2024-06-17T10:33:45Z

← Previous revision		Revision as of 10:33, 17 June 2024
Line 5:		Line 5:
	{{tone\|date=March 2019}}}}		{{tone\|date=March 2019}}}}

	'''Stack-oriented programming''' is a [[programming paradigm]] that relies on a stack (or multiple stacks) to manipulate data and/or pass parameters. Several programming languages fit this description, notably [[Forth (programming language)\|Forth]], [[~~RPL_~~(~~programming_language~~)\|RPL]], and [[PostScript]]. Stack-oriented programming languages operate on one or more [[Stack (data structure)\|stacks]], each of which may serve a different purpose. Programming constructs in other programming languages need to be modified for use in a stack-oriented system.<ref>Luerweg, T. (2015). Stack based programming paradigms. Concepts of Programming Languages–CoPL’15, 33.</ref> Most stack-oriented languages operate in ''postfix'' or [[Reverse Polish notation]]. Any arguments or parameters for a command are stated ''before'' that command. For example, postfix notation would be written {{nowrap\|<code>2, 3, multiply</code>}} instead of {{nowrap\|<code>multiply, 2, 3</code>}} (''prefix'' or [[Polish notation]]), or {{nowrap\|<code>2 multiply 3</code>}} ([[infix notation\|''infix'' notation]]). The programming languages [[Forth (programming language)\|Forth]], [[Factor (programming language)\|Factor]], [[RPL (programming language)\|RPL]], [[PostScript]], [[BibTeX]] style design language<ref>{{citation\|author=Oren Patashnik \|title=Designing BibTeX styles \|url=http://www.ctan.org/tex-archive/info/biblio/bibtex/contrib/doc/btxhak.pdf}}{{dead link\|date=April 2019}}</ref> and many [[assembly language]]s fit this paradigm.		'''Stack-oriented programming''' is a [[programming paradigm]] that relies on a stack (or multiple stacks) to manipulate data and/or pass parameters. Several programming languages fit this description, notably [[Forth (programming language)\|Forth]], [[RPL (programming language)\|RPL]], and [[PostScript]]. Stack-oriented programming languages operate on one or more [[Stack (data structure)\|stacks]], each of which may serve a different purpose. Programming constructs in other programming languages need to be modified for use in a stack-oriented system.<ref>Luerweg, T. (2015). Stack based programming paradigms. Concepts of Programming Languages–CoPL’15, 33.</ref> Most stack-oriented languages operate in ''postfix'' or [[Reverse Polish notation]]. Any arguments or parameters for a command are stated ''before'' that command. For example, postfix notation would be written {{nowrap\|<code>2, 3, multiply</code>}} instead of {{nowrap\|<code>multiply, 2, 3</code>}} (''prefix'' or [[Polish notation]]), or {{nowrap\|<code>2 multiply 3</code>}} ([[infix notation\|''infix'' notation]]). The programming languages [[Forth (programming language)\|Forth]], [[Factor (programming language)\|Factor]], [[RPL (programming language)\|RPL]], [[PostScript]], [[BibTeX]] style design language<ref>{{citation\|author=Oren Patashnik \|title=Designing BibTeX styles \|url=http://www.ctan.org/tex-archive/info/biblio/bibtex/contrib/doc/btxhak.pdf}}{{dead link\|date=April 2019}}</ref> and many [[assembly language]]s fit this paradigm.

	Stack-based algorithms manipulate data by popping data from the stack and pushing data to the stack. Stack manipulation operators govern how the stack manipulates [[data]]. To emphasize the effect of a statement, a comment is often used showing the top of the stack before and after the statement. This is known as the stack effect diagram. PostScript uses separate stacks for additional purposes, including variables, dictionaries, procedures, some typical procedures, and control flow statements. Analysis of the [[language model]] allows expressions and programs to be interpreted simply.		Stack-based algorithms manipulate data by popping data from the stack and pushing data to the stack. Stack manipulation operators govern how the stack manipulates [[data]]. To emphasize the effect of a statement, a comment is often used showing the top of the stack before and after the statement. This is known as the stack effect diagram. PostScript uses separate stacks for additional purposes, including variables, dictionaries, procedures, some typical procedures, and control flow statements. Analysis of the [[language model]] allows expressions and programs to be interpreted simply.

NeedsGlasses: correct link to RPL

2024-06-17T08:08:51Z

correct link to RPL

← Previous revision		Revision as of 08:08, 17 June 2024
Line 5:		Line 5:
	{{tone\|date=March 2019}}}}		{{tone\|date=March 2019}}}}

	'''Stack-oriented programming''' is a [[programming paradigm]] that relies on a stack (or multiple stacks) to manipulate data and/or pass parameters. Several programming languages fit this description, notably [[Forth (programming language)\|Forth]], [[RPL]], and [[PostScript]]. Stack-oriented programming languages operate on one or more [[Stack (data structure)\|stacks]], each of which may serve a different purpose. Programming constructs in other programming languages need to be modified for use in a stack-oriented system.<ref>Luerweg, T. (2015). Stack based programming paradigms. Concepts of Programming Languages–CoPL’15, 33.</ref> Most stack-oriented languages operate in ''postfix'' or [[Reverse Polish notation]]. Any arguments or parameters for a command are stated ''before'' that command. For example, postfix notation would be written {{nowrap\|<code>2, 3, multiply</code>}} instead of {{nowrap\|<code>multiply, 2, 3</code>}} (''prefix'' or [[Polish notation]]), or {{nowrap\|<code>2 multiply 3</code>}} ([[infix notation\|''infix'' notation]]). The programming languages [[Forth (programming language)\|Forth]], [[Factor (programming language)\|Factor]], [[RPL (programming language)\|RPL]], [[PostScript]], [[BibTeX]] style design language<ref>{{citation\|author=Oren Patashnik \|title=Designing BibTeX styles \|url=http://www.ctan.org/tex-archive/info/biblio/bibtex/contrib/doc/btxhak.pdf}}{{dead link\|date=April 2019}}</ref> and many [[assembly language]]s fit this paradigm.		'''Stack-oriented programming''' is a [[programming paradigm]] that relies on a stack (or multiple stacks) to manipulate data and/or pass parameters. Several programming languages fit this description, notably [[Forth (programming language)\|Forth]], [[RPL_(programming_language)\|RPL]], and [[PostScript]]. Stack-oriented programming languages operate on one or more [[Stack (data structure)\|stacks]], each of which may serve a different purpose. Programming constructs in other programming languages need to be modified for use in a stack-oriented system.<ref>Luerweg, T. (2015). Stack based programming paradigms. Concepts of Programming Languages–CoPL’15, 33.</ref> Most stack-oriented languages operate in ''postfix'' or [[Reverse Polish notation]]. Any arguments or parameters for a command are stated ''before'' that command. For example, postfix notation would be written {{nowrap\|<code>2, 3, multiply</code>}} instead of {{nowrap\|<code>multiply, 2, 3</code>}} (''prefix'' or [[Polish notation]]), or {{nowrap\|<code>2 multiply 3</code>}} ([[infix notation\|''infix'' notation]]). The programming languages [[Forth (programming language)\|Forth]], [[Factor (programming language)\|Factor]], [[RPL (programming language)\|RPL]], [[PostScript]], [[BibTeX]] style design language<ref>{{citation\|author=Oren Patashnik \|title=Designing BibTeX styles \|url=http://www.ctan.org/tex-archive/info/biblio/bibtex/contrib/doc/btxhak.pdf}}{{dead link\|date=April 2019}}</ref> and many [[assembly language]]s fit this paradigm.

	Stack-based algorithms manipulate data by popping data from the stack and pushing data to the stack. Stack manipulation operators govern how the stack manipulates [[data]]. To emphasize the effect of a statement, a comment is often used showing the top of the stack before and after the statement. This is known as the stack effect diagram. PostScript uses separate stacks for additional purposes, including variables, dictionaries, procedures, some typical procedures, and control flow statements. Analysis of the [[language model]] allows expressions and programs to be interpreted simply.		Stack-based algorithms manipulate data by popping data from the stack and pushing data to the stack. Stack manipulation operators govern how the stack manipulates [[data]]. To emphasize the effect of a statement, a comment is often used showing the top of the stack before and after the statement. This is known as the stack effect diagram. PostScript uses separate stacks for additional purposes, including variables, dictionaries, procedures, some typical procedures, and control flow statements. Analysis of the [[language model]] allows expressions and programs to be interpreted simply.

Phaesphoria: Copy edit. Fixed some sentences' grammar.

2024-06-01T16:04:09Z

Copy edit. Fixed some sentences' grammar.

← Previous revision		Revision as of 16:04, 1 June 2024
Line 7:		Line 7:
	'''Stack-oriented programming''' is a [[programming paradigm]] that relies on a stack (or multiple stacks) to manipulate data and/or pass parameters. Several programming languages fit this description, notably [[Forth (programming language)\|Forth]], [[RPL]], and [[PostScript]]. Stack-oriented programming languages operate on one or more [[Stack (data structure)\|stacks]], each of which may serve a different purpose. Programming constructs in other programming languages need to be modified for use in a stack-oriented system.<ref>Luerweg, T. (2015). Stack based programming paradigms. Concepts of Programming Languages–CoPL’15, 33.</ref> Most stack-oriented languages operate in ''postfix'' or [[Reverse Polish notation]]. Any arguments or parameters for a command are stated ''before'' that command. For example, postfix notation would be written {{nowrap\|<code>2, 3, multiply</code>}} instead of {{nowrap\|<code>multiply, 2, 3</code>}} (''prefix'' or [[Polish notation]]), or {{nowrap\|<code>2 multiply 3</code>}} ([[infix notation\|''infix'' notation]]). The programming languages [[Forth (programming language)\|Forth]], [[Factor (programming language)\|Factor]], [[RPL (programming language)\|RPL]], [[PostScript]], [[BibTeX]] style design language<ref>{{citation\|author=Oren Patashnik \|title=Designing BibTeX styles \|url=http://www.ctan.org/tex-archive/info/biblio/bibtex/contrib/doc/btxhak.pdf}}{{dead link\|date=April 2019}}</ref> and many [[assembly language]]s fit this paradigm.		'''Stack-oriented programming''' is a [[programming paradigm]] that relies on a stack (or multiple stacks) to manipulate data and/or pass parameters. Several programming languages fit this description, notably [[Forth (programming language)\|Forth]], [[RPL]], and [[PostScript]]. Stack-oriented programming languages operate on one or more [[Stack (data structure)\|stacks]], each of which may serve a different purpose. Programming constructs in other programming languages need to be modified for use in a stack-oriented system.<ref>Luerweg, T. (2015). Stack based programming paradigms. Concepts of Programming Languages–CoPL’15, 33.</ref> Most stack-oriented languages operate in ''postfix'' or [[Reverse Polish notation]]. Any arguments or parameters for a command are stated ''before'' that command. For example, postfix notation would be written {{nowrap\|<code>2, 3, multiply</code>}} instead of {{nowrap\|<code>multiply, 2, 3</code>}} (''prefix'' or [[Polish notation]]), or {{nowrap\|<code>2 multiply 3</code>}} ([[infix notation\|''infix'' notation]]). The programming languages [[Forth (programming language)\|Forth]], [[Factor (programming language)\|Factor]], [[RPL (programming language)\|RPL]], [[PostScript]], [[BibTeX]] style design language<ref>{{citation\|author=Oren Patashnik \|title=Designing BibTeX styles \|url=http://www.ctan.org/tex-archive/info/biblio/bibtex/contrib/doc/btxhak.pdf}}{{dead link\|date=April 2019}}</ref> and many [[assembly language]]s fit this paradigm.

	Stack-based algorithms ~~consider~~ data, by ~~utilising one piece of~~ data from ~~atop~~ the stack, and ~~returning~~ data ~~back atop~~ the stack. ~~The need for stack~~ manipulation operators, ~~allow~~ ~~for~~ the stack ~~to manipulate~~ [[data]]. To ~~emphasise~~ the effect of a statement, a comment is used showing the top of the stack before and after the statement. This is known as the stack effect diagram. PostScript ~~[[Stack (abstract data type)\|stacks]] consider~~ separate stacks for additional purposes~~. This~~ ~~considers~~ variables, dictionaries, procedures, ~~anatomy of~~ some typical procedures, control ~~and~~ ~~flow~~. ~~The analysis~~ of the [[language model]] allows expressions and programs to be interpreted simply ~~and theoretically~~.		Stack-based algorithms manipulate data by popping data from the stack and pushing data to the stack. Stack manipulation operators govern how the stack manipulates [[data]]. To emphasize the effect of a statement, a comment is often used showing the top of the stack before and after the statement. This is known as the stack effect diagram. PostScript uses separate stacks for additional purposes, including variables, dictionaries, procedures, some typical procedures, and control flow statements. Analysis of the [[language model]] allows expressions and programs to be interpreted simply.

	== Stack-based algorithms ==		== Stack-based algorithms ==

LVDP01 at 08:02, 30 April 2024

2024-04-30T08:02:11Z

← Previous revision		Revision as of 08:02, 30 April 2024
Line 5:		Line 5:
	{{tone\|date=March 2019}}}}		{{tone\|date=March 2019}}}}

	'''Stack-oriented programming''' is a [[programming paradigm]] that relies on a stack (or multiple stacks) to manipulate data and/or pass parameters. Several programming languages fit this description, notably [[~~Forth_~~(~~programming_language~~)\|Forth]], [[RPL]], and [[PostScript]]. Stack-oriented programming languages operate on one or more [[Stack (data structure)\|stacks]], each of which may serve a different purpose. Programming constructs in other programming languages need to be modified for use in a stack-oriented system.<ref>Luerweg, T. (2015). Stack based programming paradigms. Concepts of Programming Languages–CoPL’15, 33.</ref> Most stack-oriented languages operate in ''postfix'' or [[Reverse Polish notation]]. Any arguments or parameters for a command are stated ''before'' that command. For example, postfix notation would be written {{nowrap\|<code>2, 3, multiply</code>}} instead of {{nowrap\|<code>multiply, 2, 3</code>}} (''prefix'' or [[Polish notation]]), or {{nowrap\|<code>2 multiply 3</code>}} ([[infix notation\|''infix'' notation]]). The programming languages [[Forth (programming language)\|Forth]], [[Factor (programming language)\|Factor]], [[RPL (programming language)\|RPL]], [[PostScript]], [[BibTeX]] style design language<ref>{{citation\|author=Oren Patashnik \|title=Designing BibTeX styles \|url=http://www.ctan.org/tex-archive/info/biblio/bibtex/contrib/doc/btxhak.pdf}}{{dead link\|date=April 2019}}</ref> and many [[assembly language]]s fit this paradigm.		'''Stack-oriented programming''' is a [[programming paradigm]] that relies on a stack (or multiple stacks) to manipulate data and/or pass parameters. Several programming languages fit this description, notably [[Forth (programming language)\|Forth]], [[RPL]], and [[PostScript]]. Stack-oriented programming languages operate on one or more [[Stack (data structure)\|stacks]], each of which may serve a different purpose. Programming constructs in other programming languages need to be modified for use in a stack-oriented system.<ref>Luerweg, T. (2015). Stack based programming paradigms. Concepts of Programming Languages–CoPL’15, 33.</ref> Most stack-oriented languages operate in ''postfix'' or [[Reverse Polish notation]]. Any arguments or parameters for a command are stated ''before'' that command. For example, postfix notation would be written {{nowrap\|<code>2, 3, multiply</code>}} instead of {{nowrap\|<code>multiply, 2, 3</code>}} (''prefix'' or [[Polish notation]]), or {{nowrap\|<code>2 multiply 3</code>}} ([[infix notation\|''infix'' notation]]). The programming languages [[Forth (programming language)\|Forth]], [[Factor (programming language)\|Factor]], [[RPL (programming language)\|RPL]], [[PostScript]], [[BibTeX]] style design language<ref>{{citation\|author=Oren Patashnik \|title=Designing BibTeX styles \|url=http://www.ctan.org/tex-archive/info/biblio/bibtex/contrib/doc/btxhak.pdf}}{{dead link\|date=April 2019}}</ref> and many [[assembly language]]s fit this paradigm.

	Stack-based algorithms consider data, by utilising one piece of data from atop the stack, and returning data back atop the stack. The need for stack manipulation operators, allow for the stack to manipulate [[data]]. To emphasise the effect of a statement, a comment is used showing the top of the stack before and after the statement. This is known as the stack effect diagram. PostScript [[Stack (abstract data type)\|stacks]] consider separate stacks for additional purposes. This considers variables, dictionaries, procedures, anatomy of some typical procedures, control and flow. The analysis of the [[language model]] allows expressions and programs to be interpreted simply and theoretically.		Stack-based algorithms consider data, by utilising one piece of data from atop the stack, and returning data back atop the stack. The need for stack manipulation operators, allow for the stack to manipulate [[data]]. To emphasise the effect of a statement, a comment is used showing the top of the stack before and after the statement. This is known as the stack effect diagram. PostScript [[Stack (abstract data type)\|stacks]] consider separate stacks for additional purposes. This considers variables, dictionaries, procedures, anatomy of some typical procedures, control and flow. The analysis of the [[language model]] allows expressions and programs to be interpreted simply and theoretically.

202.138.72.82: Fixed Forth link

2024-04-30T03:35:41Z

Fixed Forth link

← Previous revision		Revision as of 03:35, 30 April 2024
Line 5:		Line 5:
	{{tone\|date=March 2019}}}}		{{tone\|date=March 2019}}}}

	'''Stack-oriented programming''' is a [[programming paradigm]] that relies on a stack (or multiple stacks) to manipulate data and/or pass parameters. Several programming languages fit this description, notably [[Forth]], [[RPL]], and [[PostScript]]. Stack-oriented programming languages operate on one or more [[Stack (data structure)\|stacks]], each of which may serve a different purpose. Programming constructs in other programming languages need to be modified for use in a stack-oriented system.<ref>Luerweg, T. (2015). Stack based programming paradigms. Concepts of Programming Languages–CoPL’15, 33.</ref> Most stack-oriented languages operate in ''postfix'' or [[Reverse Polish notation]]. Any arguments or parameters for a command are stated ''before'' that command. For example, postfix notation would be written {{nowrap\|<code>2, 3, multiply</code>}} instead of {{nowrap\|<code>multiply, 2, 3</code>}} (''prefix'' or [[Polish notation]]), or {{nowrap\|<code>2 multiply 3</code>}} ([[infix notation\|''infix'' notation]]). The programming languages [[Forth (programming language)\|Forth]], [[Factor (programming language)\|Factor]], [[RPL (programming language)\|RPL]], [[PostScript]], [[BibTeX]] style design language<ref>{{citation\|author=Oren Patashnik \|title=Designing BibTeX styles \|url=http://www.ctan.org/tex-archive/info/biblio/bibtex/contrib/doc/btxhak.pdf}}{{dead link\|date=April 2019}}</ref> and many [[assembly language]]s fit this paradigm.		'''Stack-oriented programming''' is a [[programming paradigm]] that relies on a stack (or multiple stacks) to manipulate data and/or pass parameters. Several programming languages fit this description, notably [[Forth_(programming_language)\|Forth]], [[RPL]], and [[PostScript]]. Stack-oriented programming languages operate on one or more [[Stack (data structure)\|stacks]], each of which may serve a different purpose. Programming constructs in other programming languages need to be modified for use in a stack-oriented system.<ref>Luerweg, T. (2015). Stack based programming paradigms. Concepts of Programming Languages–CoPL’15, 33.</ref> Most stack-oriented languages operate in ''postfix'' or [[Reverse Polish notation]]. Any arguments or parameters for a command are stated ''before'' that command. For example, postfix notation would be written {{nowrap\|<code>2, 3, multiply</code>}} instead of {{nowrap\|<code>multiply, 2, 3</code>}} (''prefix'' or [[Polish notation]]), or {{nowrap\|<code>2 multiply 3</code>}} ([[infix notation\|''infix'' notation]]). The programming languages [[Forth (programming language)\|Forth]], [[Factor (programming language)\|Factor]], [[RPL (programming language)\|RPL]], [[PostScript]], [[BibTeX]] style design language<ref>{{citation\|author=Oren Patashnik \|title=Designing BibTeX styles \|url=http://www.ctan.org/tex-archive/info/biblio/bibtex/contrib/doc/btxhak.pdf}}{{dead link\|date=April 2019}}</ref> and many [[assembly language]]s fit this paradigm.

	Stack-based algorithms consider data, by utilising one piece of data from atop the stack, and returning data back atop the stack. The need for stack manipulation operators, allow for the stack to manipulate [[data]]. To emphasise the effect of a statement, a comment is used showing the top of the stack before and after the statement. This is known as the stack effect diagram. PostScript [[Stack (abstract data type)\|stacks]] consider separate stacks for additional purposes. This considers variables, dictionaries, procedures, anatomy of some typical procedures, control and flow. The analysis of the [[language model]] allows expressions and programs to be interpreted simply and theoretically.		Stack-based algorithms consider data, by utilising one piece of data from atop the stack, and returning data back atop the stack. The need for stack manipulation operators, allow for the stack to manipulate [[data]]. To emphasise the effect of a statement, a comment is used showing the top of the stack before and after the statement. This is known as the stack effect diagram. PostScript [[Stack (abstract data type)\|stacks]] consider separate stacks for additional purposes. This considers variables, dictionaries, procedures, anatomy of some typical procedures, control and flow. The analysis of the [[language model]] allows expressions and programs to be interpreted simply and theoretically.

LVDP01 at 19:48, 25 March 2024

2024-03-25T19:48:25Z

← Previous revision		Revision as of 19:48, 25 March 2024
Line 5:		Line 5:
	{{tone\|date=March 2019}}}}		{{tone\|date=March 2019}}}}

	'''Stack-oriented programming ~~language~~''' is ~~one~~ that relies on a stack (or stacks) ~~for~~ ~~manipulating~~ data and/or ~~passing~~ parameters. Several programming languages fit this description, notably [[Forth]], [[RPL]], and [[PostScript]]. Stack-oriented programming languages operate on one or more [[Stack (data structure)\|stacks]], each of which may serve a different purpose. Programming constructs in other programming languages need to be modified for use in a stack-oriented system.<ref>Luerweg, T. (2015). Stack based programming paradigms. Concepts of Programming Languages–CoPL’15, 33.</ref> Most stack-oriented languages operate in ''postfix'' or [[Reverse Polish notation]]. Any arguments or parameters for a command are stated ''before'' that command. For example, postfix notation would be written {{nowrap\|<code>2, 3, multiply</code>}} instead of {{nowrap\|<code>multiply, 2, 3</code>}} (''prefix'' or [[Polish notation]]), or {{nowrap\|<code>2 multiply 3</code>}} ([[infix notation\|''infix'' notation]]). The programming languages [[Forth (programming language)\|Forth]], [[Factor (programming language)\|Factor]], [[RPL (programming language)\|RPL]], [[PostScript]], [[BibTeX]] style design language<ref>{{citation\|author=Oren Patashnik \|title=Designing BibTeX styles \|url=http://www.ctan.org/tex-archive/info/biblio/bibtex/contrib/doc/btxhak.pdf}}{{dead link\|date=April 2019}}</ref> and many [[assembly language]]s fit this paradigm.		'''Stack-oriented programming''' is a [[programming paradigm]] that relies on a stack (or multiple stacks) to manipulate data and/or pass parameters. Several programming languages fit this description, notably [[Forth]], [[RPL]], and [[PostScript]]. Stack-oriented programming languages operate on one or more [[Stack (data structure)\|stacks]], each of which may serve a different purpose. Programming constructs in other programming languages need to be modified for use in a stack-oriented system.<ref>Luerweg, T. (2015). Stack based programming paradigms. Concepts of Programming Languages–CoPL’15, 33.</ref> Most stack-oriented languages operate in ''postfix'' or [[Reverse Polish notation]]. Any arguments or parameters for a command are stated ''before'' that command. For example, postfix notation would be written {{nowrap\|<code>2, 3, multiply</code>}} instead of {{nowrap\|<code>multiply, 2, 3</code>}} (''prefix'' or [[Polish notation]]), or {{nowrap\|<code>2 multiply 3</code>}} ([[infix notation\|''infix'' notation]]). The programming languages [[Forth (programming language)\|Forth]], [[Factor (programming language)\|Factor]], [[RPL (programming language)\|RPL]], [[PostScript]], [[BibTeX]] style design language<ref>{{citation\|author=Oren Patashnik \|title=Designing BibTeX styles \|url=http://www.ctan.org/tex-archive/info/biblio/bibtex/contrib/doc/btxhak.pdf}}{{dead link\|date=April 2019}}</ref> and many [[assembly language]]s fit this paradigm.

	Stack-based algorithms consider data, by utilising one piece of data from atop the stack, and returning data back atop the stack. The need for stack manipulation operators, allow for the stack to manipulate [[data]]. To emphasise the effect of a statement, a comment is used showing the top of the stack before and after the statement. This is known as the stack effect diagram. PostScript [[Stack (abstract data type)\|stacks]] consider separate stacks for additional purposes. This considers variables, dictionaries, procedures, anatomy of some typical procedures, control and flow. The analysis of the [[language model]] allows expressions and programs to be interpreted simply and theoretically.		Stack-based algorithms consider data, by utilising one piece of data from atop the stack, and returning data back atop the stack. The need for stack manipulation operators, allow for the stack to manipulate [[data]]. To emphasise the effect of a statement, a comment is used showing the top of the stack before and after the statement. This is known as the stack effect diagram. PostScript [[Stack (abstract data type)\|stacks]] consider separate stacks for additional purposes. This considers variables, dictionaries, procedures, anatomy of some typical procedures, control and flow. The analysis of the [[language model]] allows expressions and programs to be interpreted simply and theoretically.

← Previous revision		Revision as of 08:02, 30 April 2024
Line 5:		Line 5:
	{{tone\|date=March 2019}}}}		{{tone\|date=March 2019}}}}

	'''Stack-oriented programming''' is a [[programming paradigm]] that relies on a stack (or multiple stacks) to manipulate data and/or pass parameters. Several programming languages fit this description, notably [[~~Forth_~~(~~programming_language~~)\|Forth]], [[RPL]], and [[PostScript]]. Stack-oriented programming languages operate on one or more [[Stack (data structure)\|stacks]], each of which may serve a different purpose. Programming constructs in other programming languages need to be modified for use in a stack-oriented system.<ref>Luerweg, T. (2015). Stack based programming paradigms. Concepts of Programming Languages–CoPL’15, 33.</ref> Most stack-oriented languages operate in ''postfix'' or [[Reverse Polish notation]]. Any arguments or parameters for a command are stated ''before'' that command. For example, postfix notation would be written {{nowrap\|<code>2, 3, multiply</code>}} instead of {{nowrap\|<code>multiply, 2, 3</code>}} (''prefix'' or [[Polish notation]]), or {{nowrap\|<code>2 multiply 3</code>}} ([[infix notation\|''infix'' notation]]). The programming languages [[Forth (programming language)\|Forth]], [[Factor (programming language)\|Factor]], [[RPL (programming language)\|RPL]], [[PostScript]], [[BibTeX]] style design language<ref>{{citation\|author=Oren Patashnik \|title=Designing BibTeX styles \|url=http://www.ctan.org/tex-archive/info/biblio/bibtex/contrib/doc/btxhak.pdf}}{{dead link\|date=April 2019}}</ref> and many [[assembly language]]s fit this paradigm.		'''Stack-oriented programming''' is a [[programming paradigm]] that relies on a stack (or multiple stacks) to manipulate data and/or pass parameters. Several programming languages fit this description, notably [[Forth (programming language)\|Forth]], [[RPL]], and [[PostScript]]. Stack-oriented programming languages operate on one or more [[Stack (data structure)\|stacks]], each of which may serve a different purpose. Programming constructs in other programming languages need to be modified for use in a stack-oriented system.<ref>Luerweg, T. (2015). Stack based programming paradigms. Concepts of Programming Languages–CoPL’15, 33.</ref> Most stack-oriented languages operate in ''postfix'' or [[Reverse Polish notation]]. Any arguments or parameters for a command are stated ''before'' that command. For example, postfix notation would be written {{nowrap\|<code>2, 3, multiply</code>}} instead of {{nowrap\|<code>multiply, 2, 3</code>}} (''prefix'' or [[Polish notation]]), or {{nowrap\|<code>2 multiply 3</code>}} ([[infix notation\|''infix'' notation]]). The programming languages [[Forth (programming language)\|Forth]], [[Factor (programming language)\|Factor]], [[RPL (programming language)\|RPL]], [[PostScript]], [[BibTeX]] style design language<ref>{{citation\|author=Oren Patashnik \|title=Designing BibTeX styles \|url=http://www.ctan.org/tex-archive/info/biblio/bibtex/contrib/doc/btxhak.pdf}}{{dead link\|date=April 2019}}</ref> and many [[assembly language]]s fit this paradigm.

	Stack-based algorithms consider data, by utilising one piece of data from atop the stack, and returning data back atop the stack. The need for stack manipulation operators, allow for the stack to manipulate [[data]]. To emphasise the effect of a statement, a comment is used showing the top of the stack before and after the statement. This is known as the stack effect diagram. PostScript [[Stack (abstract data type)\|stacks]] consider separate stacks for additional purposes. This considers variables, dictionaries, procedures, anatomy of some typical procedures, control and flow. The analysis of the [[language model]] allows expressions and programs to be interpreted simply and theoretically.		Stack-based algorithms consider data, by utilising one piece of data from atop the stack, and returning data back atop the stack. The need for stack manipulation operators, allow for the stack to manipulate [[data]]. To emphasise the effect of a statement, a comment is used showing the top of the stack before and after the statement. This is known as the stack effect diagram. PostScript [[Stack (abstract data type)\|stacks]] consider separate stacks for additional purposes. This considers variables, dictionaries, procedures, anatomy of some typical procedures, control and flow. The analysis of the [[language model]] allows expressions and programs to be interpreted simply and theoretically.

← Previous revision		Revision as of 03:35, 30 April 2024
Line 5:		Line 5:
	{{tone\|date=March 2019}}}}		{{tone\|date=March 2019}}}}

	'''Stack-oriented programming''' is a [[programming paradigm]] that relies on a stack (or multiple stacks) to manipulate data and/or pass parameters. Several programming languages fit this description, notably [[Forth]], [[RPL]], and [[PostScript]]. Stack-oriented programming languages operate on one or more [[Stack (data structure)\|stacks]], each of which may serve a different purpose. Programming constructs in other programming languages need to be modified for use in a stack-oriented system.<ref>Luerweg, T. (2015). Stack based programming paradigms. Concepts of Programming Languages–CoPL’15, 33.</ref> Most stack-oriented languages operate in ''postfix'' or [[Reverse Polish notation]]. Any arguments or parameters for a command are stated ''before'' that command. For example, postfix notation would be written {{nowrap\|<code>2, 3, multiply</code>}} instead of {{nowrap\|<code>multiply, 2, 3</code>}} (''prefix'' or [[Polish notation]]), or {{nowrap\|<code>2 multiply 3</code>}} ([[infix notation\|''infix'' notation]]). The programming languages [[Forth (programming language)\|Forth]], [[Factor (programming language)\|Factor]], [[RPL (programming language)\|RPL]], [[PostScript]], [[BibTeX]] style design language<ref>{{citation\|author=Oren Patashnik \|title=Designing BibTeX styles \|url=http://www.ctan.org/tex-archive/info/biblio/bibtex/contrib/doc/btxhak.pdf}}{{dead link\|date=April 2019}}</ref> and many [[assembly language]]s fit this paradigm.		'''Stack-oriented programming''' is a [[programming paradigm]] that relies on a stack (or multiple stacks) to manipulate data and/or pass parameters. Several programming languages fit this description, notably [[Forth_(programming_language)\|Forth]], [[RPL]], and [[PostScript]]. Stack-oriented programming languages operate on one or more [[Stack (data structure)\|stacks]], each of which may serve a different purpose. Programming constructs in other programming languages need to be modified for use in a stack-oriented system.<ref>Luerweg, T. (2015). Stack based programming paradigms. Concepts of Programming Languages–CoPL’15, 33.</ref> Most stack-oriented languages operate in ''postfix'' or [[Reverse Polish notation]]. Any arguments or parameters for a command are stated ''before'' that command. For example, postfix notation would be written {{nowrap\|<code>2, 3, multiply</code>}} instead of {{nowrap\|<code>multiply, 2, 3</code>}} (''prefix'' or [[Polish notation]]), or {{nowrap\|<code>2 multiply 3</code>}} ([[infix notation\|''infix'' notation]]). The programming languages [[Forth (programming language)\|Forth]], [[Factor (programming language)\|Factor]], [[RPL (programming language)\|RPL]], [[PostScript]], [[BibTeX]] style design language<ref>{{citation\|author=Oren Patashnik \|title=Designing BibTeX styles \|url=http://www.ctan.org/tex-archive/info/biblio/bibtex/contrib/doc/btxhak.pdf}}{{dead link\|date=April 2019}}</ref> and many [[assembly language]]s fit this paradigm.

	Stack-based algorithms consider data, by utilising one piece of data from atop the stack, and returning data back atop the stack. The need for stack manipulation operators, allow for the stack to manipulate [[data]]. To emphasise the effect of a statement, a comment is used showing the top of the stack before and after the statement. This is known as the stack effect diagram. PostScript [[Stack (abstract data type)\|stacks]] consider separate stacks for additional purposes. This considers variables, dictionaries, procedures, anatomy of some typical procedures, control and flow. The analysis of the [[language model]] allows expressions and programs to be interpreted simply and theoretically.		Stack-based algorithms consider data, by utilising one piece of data from atop the stack, and returning data back atop the stack. The need for stack manipulation operators, allow for the stack to manipulate [[data]]. To emphasise the effect of a statement, a comment is used showing the top of the stack before and after the statement. This is known as the stack effect diagram. PostScript [[Stack (abstract data type)\|stacks]] consider separate stacks for additional purposes. This considers variables, dictionaries, procedures, anatomy of some typical procedures, control and flow. The analysis of the [[language model]] allows expressions and programs to be interpreted simply and theoretically.

← Previous revision		Revision as of 19:48, 25 March 2024
Line 5:		Line 5:
	{{tone\|date=March 2019}}}}		{{tone\|date=March 2019}}}}

	'''Stack-oriented programming ~~language~~''' is ~~one~~ that relies on a stack (or stacks) ~~for~~ ~~manipulating~~ data and/or ~~passing~~ parameters. Several programming languages fit this description, notably [[Forth]], [[RPL]], and [[PostScript]]. Stack-oriented programming languages operate on one or more [[Stack (data structure)\|stacks]], each of which may serve a different purpose. Programming constructs in other programming languages need to be modified for use in a stack-oriented system.<ref>Luerweg, T. (2015). Stack based programming paradigms. Concepts of Programming Languages–CoPL’15, 33.</ref> Most stack-oriented languages operate in ''postfix'' or [[Reverse Polish notation]]. Any arguments or parameters for a command are stated ''before'' that command. For example, postfix notation would be written {{nowrap\|<code>2, 3, multiply</code>}} instead of {{nowrap\|<code>multiply, 2, 3</code>}} (''prefix'' or [[Polish notation]]), or {{nowrap\|<code>2 multiply 3</code>}} ([[infix notation\|''infix'' notation]]). The programming languages [[Forth (programming language)\|Forth]], [[Factor (programming language)\|Factor]], [[RPL (programming language)\|RPL]], [[PostScript]], [[BibTeX]] style design language<ref>{{citation\|author=Oren Patashnik \|title=Designing BibTeX styles \|url=http://www.ctan.org/tex-archive/info/biblio/bibtex/contrib/doc/btxhak.pdf}}{{dead link\|date=April 2019}}</ref> and many [[assembly language]]s fit this paradigm.		'''Stack-oriented programming''' is a [[programming paradigm]] that relies on a stack (or multiple stacks) to manipulate data and/or pass parameters. Several programming languages fit this description, notably [[Forth]], [[RPL]], and [[PostScript]]. Stack-oriented programming languages operate on one or more [[Stack (data structure)\|stacks]], each of which may serve a different purpose. Programming constructs in other programming languages need to be modified for use in a stack-oriented system.<ref>Luerweg, T. (2015). Stack based programming paradigms. Concepts of Programming Languages–CoPL’15, 33.</ref> Most stack-oriented languages operate in ''postfix'' or [[Reverse Polish notation]]. Any arguments or parameters for a command are stated ''before'' that command. For example, postfix notation would be written {{nowrap\|<code>2, 3, multiply</code>}} instead of {{nowrap\|<code>multiply, 2, 3</code>}} (''prefix'' or [[Polish notation]]), or {{nowrap\|<code>2 multiply 3</code>}} ([[infix notation\|''infix'' notation]]). The programming languages [[Forth (programming language)\|Forth]], [[Factor (programming language)\|Factor]], [[RPL (programming language)\|RPL]], [[PostScript]], [[BibTeX]] style design language<ref>{{citation\|author=Oren Patashnik \|title=Designing BibTeX styles \|url=http://www.ctan.org/tex-archive/info/biblio/bibtex/contrib/doc/btxhak.pdf}}{{dead link\|date=April 2019}}</ref> and many [[assembly language]]s fit this paradigm.

	Stack-based algorithms consider data, by utilising one piece of data from atop the stack, and returning data back atop the stack. The need for stack manipulation operators, allow for the stack to manipulate [[data]]. To emphasise the effect of a statement, a comment is used showing the top of the stack before and after the statement. This is known as the stack effect diagram. PostScript [[Stack (abstract data type)\|stacks]] consider separate stacks for additional purposes. This considers variables, dictionaries, procedures, anatomy of some typical procedures, control and flow. The analysis of the [[language model]] allows expressions and programs to be interpreted simply and theoretically.		Stack-based algorithms consider data, by utilising one piece of data from atop the stack, and returning data back atop the stack. The need for stack manipulation operators, allow for the stack to manipulate [[data]]. To emphasise the effect of a statement, a comment is used showing the top of the stack before and after the statement. This is known as the stack effect diagram. PostScript [[Stack (abstract data type)\|stacks]] consider separate stacks for additional purposes. This considers variables, dictionaries, procedures, anatomy of some typical procedures, control and flow. The analysis of the [[language model]] allows expressions and programs to be interpreted simply and theoretically.