Concurrent constraint logic programming - Revision history

Onel5969: Disambiguating links to Deadlock (link changed to Deadlock (computer science)) using DisamAssist.

2024-08-20T21:24:33Z

Disambiguating links to Deadlock (link changed to Deadlock (computer science)) using DisamAssist.

← Previous revision		Revision as of 21:24, 20 August 2024
Line 20:		Line 20:
	A second effect of the difference between the non-concurrent and the concurrent version is that concurrent constraint logic programming is specifically designed to allow processes to run without terminating. Non-terminating processes are common in general in concurrent processing; the concurrent version of constraint logic programming implements them by not using the condition of failure: if no clause is applicable for rewriting a goal, the process evaluating this goal stops instead of making the whole evaluation fail like in non-concurrent constraint logic programming. As a result, the process evaluating a goal may be stopped because no clause is available to proceed, but at the same time the other processes keep running.		A second effect of the difference between the non-concurrent and the concurrent version is that concurrent constraint logic programming is specifically designed to allow processes to run without terminating. Non-terminating processes are common in general in concurrent processing; the concurrent version of constraint logic programming implements them by not using the condition of failure: if no clause is applicable for rewriting a goal, the process evaluating this goal stops instead of making the whole evaluation fail like in non-concurrent constraint logic programming. As a result, the process evaluating a goal may be stopped because no clause is available to proceed, but at the same time the other processes keep running.

	Synchronization among processes that are solving different goals is achieved via the use of guards. If a goal cannot be rewritten because all clauses that could be used have a guard that is not entailed by the constraint store, the process solving this goal is blocked until the other processes add the constraints that are necessary to entail the guard of at least one of the applicable clauses. This synchronization is subject to [[deadlock]]s: if all goals are blocked, no new constraints will be added and therefore no goal will ever be unblocked.		Synchronization among processes that are solving different goals is achieved via the use of guards. If a goal cannot be rewritten because all clauses that could be used have a guard that is not entailed by the constraint store, the process solving this goal is blocked until the other processes add the constraints that are necessary to entail the guard of at least one of the applicable clauses. This synchronization is subject to [[Deadlock (computer science)\|deadlock]]s: if all goals are blocked, no new constraints will be added and therefore no goal will ever be unblocked.

	A third effect of the difference between concurrent and non-concurrent logic programming is in the way a goal is equated to the head of a fresh variant of a clause. Operationally, this is done by checking whether the variables in the head can be equated to terms in such a way the head is equal to the goal. This rule differs from the corresponding rule for constraint logic programming in that it only allows adding constraints in the form variable=term, where the variable is one of the head. This limitation can be seen as a form of directionality, in that the goal and the clause head are treated differently.		A third effect of the difference between concurrent and non-concurrent logic programming is in the way a goal is equated to the head of a fresh variant of a clause. Operationally, this is done by checking whether the variables in the head can be equated to terms in such a way the head is equal to the goal. This rule differs from the corresponding rule for constraint logic programming in that it only allows adding constraints in the form variable=term, where the variable is one of the head. This limitation can be seen as a form of directionality, in that the goal and the clause head are treated differently.

Citation bot: Added doi. | Use this bot. Report bugs. | Suggested by Abductive | Category:Concurrent computing | #UCB_Category 24/44

2024-03-16T08:49:59Z

Added doi. | Use this bot. Report bugs. | Suggested by Abductive | Category:Concurrent computing | #UCB_Category 24/44

← Previous revision		Revision as of 08:49, 16 March 2024
Line 30:		Line 30:
	==History==		==History==

	The study of concurrent constraint logic programming started at the end of the 1980s, when some of the principles of [[concurrent logic programming]] were integrated into constraint logic programming by [[Michael J. Maher]]. The theoretical properties of concurrent constraint logic programming were later studied by various authors, including Martin Rinard and Vijay A. Saraswat.<ref>{{Cite book \|last=Saraswat \|first=Vijay A. \|url=http://dx.doi.org/10.7551/mitpress/2086.001.0001 \|title=Concurrent Constraint Programming \|date=1993 \|publisher=The MIT Press \|isbn=978-0-262-29097-5}}</ref>		The study of concurrent constraint logic programming started at the end of the 1980s, when some of the principles of [[concurrent logic programming]] were integrated into constraint logic programming by [[Michael J. Maher]]. The theoretical properties of concurrent constraint logic programming were later studied by various authors, including Martin Rinard and Vijay A. Saraswat.<ref>{{Cite book \|last=Saraswat \|first=Vijay A. \|url=http://dx.doi.org/10.7551/mitpress/2086.001.0001 \|title=Concurrent Constraint Programming \|date=1993 \|publisher=The MIT Press \|doi=10.7551/mitpress/2086.001.0001 \|isbn=978-0-262-29097-5}}</ref>

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

2A02:1812:110C:DC00:10C4:CC2C:B726:832F at 15:50, 11 October 2023

2023-10-11T15:50:11Z

← Previous revision		Revision as of 15:50, 11 October 2023
Line 1:		Line 1:
	'''Concurrent constraint logic programming''' is a version of [[constraint logic programming]] aimed primarily at programming [[concurrent process]]es rather than (or in addition to) solving [[constraint satisfaction problem]]s. Goals in constraint logic programming are evaluated concurrently; a concurrent process is therefore programmed as the evaluation of a goal by the [[Interpreter (computing)\|interpreter]].		'''Concurrent constraint logic programming''' is a version of [[constraint logic programming]] aimed primarily at programming [[concurrent process]]es rather than (or in addition to) solving [[constraint satisfaction problem]]s. Goals in constraint logic programming are evaluated concurrently; a concurrent process is therefore programmed as the evaluation of a goal by the [[Interpreter (computing)\|interpreter]].

	Syntactically, concurrent ~~constraints~~ logic programs are similar to non-concurrent programs, the only exception being that clauses include [[Guard (computing)\|guards]], which are constraints that may block the applicability of the clause under some conditions. Semantically, concurrent constraint logic programming differs from its non-concurrent versions because a goal evaluation is intended to realize a concurrent process rather than finding a solution to a problem. Most notably, this difference affects how the interpreter behaves when more than one clause is applicable: non-concurrent constraint logic programming [[Recursion\|recursively]] tries all clauses; concurrent constraint logic programming chooses only one. This is the most evident effect of an intended ''directionality'' of the interpreter, which never revise a choice it has previously taken. Other effects of this are the semantical possibility of having a goal that cannot be proved while the whole evaluation does not fail, and a particular way for equating a goal and a clause head.		[[syntax (logic)\|Syntactically]], concurrent constraint logic programs are similar to non-concurrent programs, the only exception being that clauses include [[Guard (computing)\|guards]], which are constraints that may block the applicability of the clause under some conditions. Semantically, concurrent constraint logic programming differs from its non-concurrent versions because a goal evaluation is intended to realize a concurrent process rather than finding a solution to a problem. Most notably, this difference affects how the interpreter behaves when more than one clause is applicable: non-concurrent constraint logic programming [[Recursion\|recursively]] tries all clauses; concurrent constraint logic programming chooses only one. This is the most evident effect of an intended ''directionality'' of the interpreter, which never revise a choice it has previously taken. Other effects of this are the semantical possibility of having a goal that cannot be proved while the whole evaluation does not fail, and a particular way for equating a goal and a clause head.

	[[Constraint handling rules]] can be seen as a form of concurrent constraint logic programming,<ref>Frühwirth, Thom. "[https://www.sciencedirect.com/science/article/pii/S0743106698100055 Theory and practice of constraint handling rules]." The Journal of Logic Programming 37.1-3 (1998): 95-138.</ref> but are used for programming a constraint simplifier or solver rather than concurrent processes.		[[Constraint handling rules]] can be seen as a form of concurrent constraint logic programming,<ref>Frühwirth, Thom. "[https://www.sciencedirect.com/science/article/pii/S0743106698100055 Theory and practice of constraint handling rules]." [[The Journal of Logic Programming]] 37.1-3 (1998): 95-138.</ref> but are used for programming a constraint simplifier or solver rather than concurrent processes.

	==Description==		==Description==

Felix QW: Tidy refs

2023-08-04T18:50:37Z

Tidy refs

← Previous revision		Revision as of 18:50, 4 August 2023
Line 30:		Line 30:
	==History==		==History==

	The study of concurrent constraint logic programming started at the end of the 1980s, when some of the principles of [[concurrent logic programming]] were integrated into constraint logic programming by [[Michael J. Maher]]. The theoretical properties of concurrent constraint logic programming were later studied by various authors, including ~~[https~~://~~people~~.~~csail~~.~~mit~~.~~edu~~/~~rinard~~/~~paper/popl90~~.~~pdf~~ ~~Martin~~ ~~Rinard~~ ~~and~~ ~~Vijay~~ A. ~~Saraswat].~~		The study of concurrent constraint logic programming started at the end of the 1980s, when some of the principles of [[concurrent logic programming]] were integrated into constraint logic programming by [[Michael J. Maher]]. The theoretical properties of concurrent constraint logic programming were later studied by various authors, including Martin Rinard and Vijay A. Saraswat.<ref>{{Cite book \|last=Saraswat \|first=Vijay A. \|url=http://dx.doi.org/10.7551/mitpress/2086.001.0001 \|title=Concurrent Constraint Programming \|date=1993 \|publisher=The MIT Press \|isbn=978-0-262-29097-5}}</ref>

	==See also==		==See also==
Line 39:		Line 39:
	* [[Alice (programming language)\|Alice]]		* [[Alice (programming language)\|Alice]]

	==References==		== References ==
			{{reflist}}

			==Bibliography==

	*{{cite book		*{{cite book
Line 70:		Line 73:
	}}		}}


	;Specific
	<references />

	[[Category:Constraint logic programming]]		[[Category:Constraint logic programming]]

130.44.144.20: /* History */

2023-02-27T13:47:07Z

History

← Previous revision		Revision as of 13:47, 27 February 2023
Line 30:		Line 30:
	==History==		==History==

	The study of concurrent constraint logic programming started at the end of the 1980s, when some of the principles of [[concurrent logic programming]] were integrated into constraint logic programming by [[Michael J. Maher]]. The theoretical properties of concurrent constraint logic programming were later studied by various authors.		The study of concurrent constraint logic programming started at the end of the 1980s, when some of the principles of [[concurrent logic programming]] were integrated into constraint logic programming by [[Michael J. Maher]]. The theoretical properties of concurrent constraint logic programming were later studied by various authors, including [https://people.csail.mit.edu/rinard/paper/popl90.pdf Martin Rinard and Vijay A. Saraswat].

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

Dialectric: /* History */ rm unreferenced redlink name

2020-06-30T14:35:52Z

History: rm unreferenced redlink name

← Previous revision		Revision as of 14:35, 30 June 2020
Line 30:		Line 30:
	==History==		==History==

	The study of concurrent constraint logic programming started at the end of the 1980s, when some of the principles of [[concurrent logic programming]] were integrated into constraint logic programming by [[Michael J. Maher]]. The theoretical properties of concurrent constraint logic programming were later studied by various authors~~, such as [[Vijay A. Saraswat]]~~.		The study of concurrent constraint logic programming started at the end of the 1980s, when some of the principles of [[concurrent logic programming]] were integrated into constraint logic programming by [[Michael J. Maher]]. The theoretical properties of concurrent constraint logic programming were later studied by various authors.

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

OAbot: Open access bot: doi added to citation with #oabot.

2019-10-12T16:59:44Z

Open access bot: doi added to citation with #oabot.

← Previous revision		Revision as of 16:59, 12 October 2019
Line 67:		Line 67:
	\| year=1994		\| year=1994
	\| doi=10.1016/0743-1066(94)90033-7		\| doi=10.1016/0743-1066(94)90033-7
			\| doi-access=free
	}}		}}

Citation bot: Alter: journal. | You can use this bot yourself. Report bugs here.| Activated by User:Marianne Zimmerman

2019-07-08T04:47:10Z

Alter: journal. | You can use this bot yourself. Report bugs here.| Activated by User:Marianne Zimmerman

← Previous revision		Revision as of 04:47, 8 July 2019
Line 62:		Line 62:
	\|author2=Michael J. Maher		\|author2=Michael J. Maher
	\| title=Constraint logic programming: a survey		\| title=Constraint logic programming: a survey
	\| journal=Journal of ~~logic~~ ~~programming~~		\| journal=Journal of Logic Programming
	\| volume=19/20		\| volume=19/20
	\| pages=503–581		\| pages=503–581

Beland: convert HTML entities, punctuation (via WP:JWB)

2019-06-06T00:48:18Z

convert HTML entities, punctuation (via WP:JWB)

← Previous revision		Revision as of 00:48, 6 June 2019
Line 51:		Line 51:
	*{{cite book		*{{cite book
	\| first=Thom		\| first=Thom
	\| last=~~Frühwirth~~		\| last=Frühwirth
	\|author2=Slim Abdennadher		\|author2=Slim Abdennadher
	\| title=Essentials of constraint programming		\| title=Essentials of constraint programming

GünniX: /* References */

2018-07-05T05:13:43Z

References

← Previous revision		Revision as of 05:13, 5 July 2018
Line 68:		Line 68:
	\| doi=10.1016/0743-1066(94)90033-7		\| doi=10.1016/0743-1066(94)90033-7
	}}		}}

			;Specific
			<references />

	[[Category:Constraint logic programming]]		[[Category:Constraint logic programming]]