Changes for page Products

Summary

• Page properties (1 modified, 0 added, 0 removed)

Details

Page properties

Content

...	...	@@ -5,7 +5,7 @@
5	5	= #apice() Products =
6	6
7	7	Research activities in the #apice() lab often result in //products// that can be shared and freely used, consisting mainly of software //technologies// — programming languages and frameworks, software infrastructures — but also including //methodologies// for the engineering of complex computational systems.
8		-
	8	+<p/>
9	9	Below, the current list of products actively supported &mdash; mainly by the members of the #alice() research group &mdash; along with contact details and the corresponding web spaces &mdash; whenever available.
10	10	The list is ordered alphabetically.
11	11
...	...	@@ -12,7 +12,7 @@
12	12	== #alchemist() ==
13	13
14	14	#alchemist() is a simulation framework offering both high performance and flexibility. Alchemist tries to get the best from ABMs and stochastic simulators and build an hybrid.
15		-
	15	+<p/>
16	16	**Space**: [[#alchemist() Home>>Alchemist.WebHome]]
17	17	<br/>
18	18	**Contact**: [[Danilo Pianini>>DaniloPianini.WebHome]]
...	...	@@ -20,10 +20,10 @@
20	20	== ALOO ==
21	21
22	22	(% class="imgfloatleft" %)((([[image:aloo256x256.jpg||height="90" width="90" align="left"]])))
23		-
	23	+<p/>
24	24	ALOO is a general-purpose concurrent programming language based on objects and agents as first-class abstractions. It is a Concurrent OOP language where concurrency aspects (parallelisms, asynchronous programming, etc) are modeled in terms of agent-oriented abstractions. Or, it can be conceived as an Agent-Oriented Programming language not based on logic programming - like state-of-the-art AOP languages - but on OOP. The language comes with a platform (compiler, runtime) and an Eclipse-based IDE.
25	25	ALOO is the most recent evolution of the simpAL project.
26		-
	26	+<p/>
27	27	**Space**: [[ALOO Home>>ALOO.WebHome]]
28	28	<br/>
29	29	**Contact**: [[Alessandro Ricci>>AlessandroRicci.WebHome]]
...	...	@@ -31,9 +31,9 @@
31	31	== #cartago() ==
32	32
33	33	#cartago() is an infrastructure for the development and execution of artifact-based computational environments for Multi-Agent Systems.
34		-
	34	+<p/>
35	35	#cartago() is based on the #aea() (Agents and Artifacts) meta&#45;model model, which introduces the //artifact// abstraction as a first&#45;class building block to model and engineer those objects, resources, tools, that can be dynamically constructed, shared and co-used by agents to perform their activities, both individual and social.
36		-
	36	+<p/>
37	37	**Space**: [[#cartago() Home>>CARTAGO.WebHome]]
38	38	<br/>
39	39	**Contact**: [[Alessandro Ricci>>AlessandroRicci.WebHome]]
...	...	@@ -40,22 +40,22 @@
40	40
41	41	== #hm() ==
42	42
43		-(% class="imgfloatleft" %)((([[image:Products.HomeManager@logoHM2.jpg||height="100" width="73" align="left"]])))
44		-
	43	+(% class="imgfloatleft" %)((([[image:logoHM2.jpg||height="100" width="73" align="left"]])))
	44	+<p/>
45	45	#hm() is a prototype agent-based platform for the construction of Socio-Technical Smart Spaces and Smart Environments, starting from the control of an intelligent home to a wider Smart Living scenario, where home users are situated in space and time in the surrounding environment.
46	46	The house is seen as an intelligent environment made of independent devices that participate to an agent society: following the Butlers vision and architecture, Home Manager aims both to enable a rich interaction experience for the user in the interaction with the smart house, and to anticipate his/her needs based both on the user's habits and policies, while respecting the general system policies which capture the global goals and constraints.
47	47	The implementation is Java-based, developed on top of the TuCSoN agent infrastructure, and deployable also on low-cost devices such as Raspberry PI2.
48		-
	48	+<p/>
49	49	**Space**: [[#hm() Home>>Products.HomeManager]]
50		-<br />
	50	+<br/>
51	51	**Contact**: [[Roberta Calegari>>RobertaCalegari.WebHome]]
52	52
53	53	== #moklong() ==
54	54
55	55	(% class="imgfloatleft" %)((([[image:image.jpg||height="70" width="130" align="left"]])))
56		-
	56	+<p/>
57	57	#moklong() (#mok() for short) is a model for knowledge self-organisation, exploiting the biochemical metaphor for its basic abstractions, and biochemical coordination as its coordination model.
58		-
	58	+<p/>
59	59	**Space**: [[#mok() Home>>MoK.WebHome]]
60	60	<br/>
61	61	**Contact**: [[Stefano Mariani>>StefanoMariani.WebHome]]
...	...	@@ -63,7 +63,7 @@
63	63	== MS-BioNET ==
64	64
65	65	MS-BioNet (MultiScale-Biochemical NETwork) is a computational framework for modelling and simulating large networks of compartments hosting a chemical solution and communicating through an enhanced model of chemical reaction addressing molecule transfer.
66		-
	66	+<p/>
67	67	**Space**: [[MS-BioNET Home>>MS-BioNET.WebHome]]
68	68	<br/>
69	69	**Contact**: [[Sara Montagna>>SaraMontagna.WebHome]]
...	...	@@ -75,7 +75,7 @@
75	75
76	76	* an API layer for automated mapping of Java types into Prolog types (and viceversa) and seamless exploitation of the Generic Collections Framework;
77	77	* an annotation layer, that aims at truly extending Java programming with the ability of specifying Prolog&#45;based declarative implementations of Java methods, relying on Java annotations.
78		-
	78	+<p/>
79	79	**Space**: [[P@J>>Tuprolog.PatJ]]
80	80	<br/>
81	81	**Contact**: [[Mirko Viroli>>MirkoViroli.WebHome]]
...	...	@@ -83,15 +83,15 @@
83	83	== #respect() ==
84	84
85	85	(% class="imgfloatleft" %)((([[image:r_logo.png||height="109" width="100" align="left"]])))
86		-
	86	+<p/>
87	87	#respect() is a logic-based coordination language both to define the behaviour of tuple centres and to coordinate software agents.
88		-
	88	+<p/>
89	89	#respect() assumes a tuple-based coordination model, where communication is based on logic tuples, and the behaviour of the coordination media in response to communication events is not fixed once and for all by the coordination model, but can be defined and tailored according to system's global requirements.
90	90	According to this conceptual framework, #respect() has a twofold role:
91	91
92	92	* as a specification language - #respect() makes it possible to filter communication events and associate them to reactions by means of first-order logic tuples.
93	93	* as a reaction language - #respect() supports the notion of reaction as a computational activity to be executed locally to a tuple centre in response to communication events, by providing for both a logic-based syntax for the definition of reactions, and a model for their execution.
94		-
	94	+<p/>
95	95	**Space**: [[#respect() Home>>ReSpecT.WebHome]]
96	96	<br/>
97	97	**Contact**: [[Stefano Mariani>>StefanoMariani.WebHome]]
...	...	@@ -99,11 +99,11 @@
99	99	== #simpa() ==
100	100
101	101	(% class="imgfloatleft" %)((([[image:simpa-logo.jpg||height="109" width="100" align="left"]])))
102		-
	102	+<p/>
103	103	#simpa() is a framework extending the basic Java environment with an agent-oriented abstraction layer for programming complex (concurrent in particular) applications.
104		-
	104	+<p/>
105	105	#simpa() is based on the #aea() (Agents and Artifacts) programming model, which introduces high-level metaphors taken from human society, namely agents &#45; analogous to humans, as executors of activities and activities &mdash; and artifacts &mdash; analogous of the objects, resources, tools that are dynamically constructed, used, manipulated by humans to support / realise their individual and social activities.
106		-
	106	+<p/>
107	107	**Space**: [[#simpa() Home>>SimpA.WebHome]]
108	108	<br/>
109	109	**Contact**: [[Alessandro Ricci>>AlessandroRicci.WebHome]]
...	...	@@ -111,13 +111,13 @@
111	111	== simpAL ==
112	112
113	113	simpAL is a general-purpose programming language and platform for developing concurrent and distributed applications.
114		-
	114	+<p/>
115	115	simpAL is based on the #aea() (Agents and Artifacts) programming model, which introduces high-level metaphors taken from human society, namely agents &mdash; analogous to humans, as executors of activities and activities &mdash; and artifacts &mdash; analogous of the objects, resources, tools that are dynamically constructed, used, manipulated by humans to support / realise their individual and social activities.
116		-
117		-Unlike #simpa(), simpAL is not a Java extension, but a fully independent language and platform.
118		-
	116	+<p/>
	117	+Differently from #simpa(), simpAL is not a Java extension, but a fully independent language and platform.
	118	+<p/>
119	119	**Space**: [[simpAL Home>>SimpAL.WebHome]]
120		-
	120	+<br/>
121	121	**Contact**: [[Alessandro Ricci>>AlessandroRicci.WebHome]]
122	122
123	123	== #soda() ==
...	...	@@ -126,7 +126,7 @@
126	126	#soda() (Societies in Open and Distributed Agent spaces) is a methodology for the analysis and design of complex agent-based systems. #soda() is not concerned with //intra-agent issues//: designing a multi-agent system with #soda() leads to defining agents in terms of their required observable behaviour and their role in the multi-agent system.
127	127	Instead, #soda() concentrated on //inter-agent// issues, like the engineering of societies and infrastructures for multi-agent systems.
128	128	Recently a new and extended version of the methodology has been proposed, which takes into account both the Agents and Aartifacts (#aea()) meta-model, and a mechanism to manage the complexity of system description.
129		-
	129	+<p/>
130	130	**Space**: [[#soda() Home>>SODA.WebHome]]
131	131	<br/>
132	132	**Contact**: [[Ambra Molesini>>AmbraMolesini.WebHome]]
...	...	@@ -134,11 +134,11 @@
134	134	== #traumatracker() ==
135	135
136	136	(% class="imgfloatleft" %)((([[image:TT-logo.png||height="100" width="100" align="left"]])))
137		-
	137	+<p/>
138	138	Developed in collaboration with the Trauma Center and the Emergency Department of the "Bufalini" Hospital in Cesena, Italy, #traumatracker() is a project in which agent technologies are exploited to realise Personal Medical Digital Assistant Agents (PMDA) supporting a Trauma Team in trauma management operations. This project aims at exploring the fruitful integration of software personal agents with wearable/eyewear computing, based on mobile and wearable devices such as smart-glasses.
139		-
	139	+<p/>
140	140	The key functionality of #traumatracker() is to keep track of relevant events occurring during the management of a trauma, for two basic purposes. The first one is about tracking, i.e. to have an accurate documentation of the trauma, to automate the creation (and management) of reports and to enable offlne data analysis. The second one is a first kind of assistance, in terms of the real-time generation of warnings and suggestions to be perceived through the smartglasses, by analysing and reasoning upon the tracked events and data. The system has been designed and developed using cognitive agent technologies based on the Belief-Desire-Intention (BDI) architecture, as supported by the JaCaMo agent platform.
141		-
	141	+<p/>
142	142	**Space**: [[#traumatracker() Home>>TraumaTracker.WebHome]]
143	143	<br/>
144	144	**Contact**: [[Angelo Croatti>>https://www.unibo.it/sitoweb/a.croatti/en]], [[Sara Montagna>>https://www.unibo.it/sitoweb/sara.montagna/en]], [[Alessandro Ricci>>https://www.unibo.it/sitoweb/a.ricci/en]]
...	...	@@ -146,16 +146,16 @@
146	146	== #tucson() ==
147	147
148	148	(% class="imgfloatleft" %)((([[image:tucson.jpg||height="137" width="100" align="left"]])))
149		-
	149	+<p/>
150	150	#tucson() (Tuple Centres over the Network) is a model (and related infrastructure and technology) for the coordination of Internet agents.
151		-
	151	+<p/>
152	152	#tucson() exploits a notion of local tuple-based interaction space, called tuple centre, which is a tuple space enhanced with the notion of behaviour specification.
153	153	By programming its behaviour in response to communication events, a tuple centre can embody coordination laws.
154	154	Several issues critical to Internet applications, such as heterogeneity and dynamicity of the Internet nodes, can then be charged upon tuple centres, and transparently to agents, which can then be designed independently of the different node architectures, according to a straightforward interaction protocol.
155		-
	155	+<p/>
156	156	The #tucson() coordination language provides agents with a twofold perception of the #tucson() interaction space, as either as a global space made up of uniquely denoted coordination media, or a collection of local spaces associated to Internet nodes.
157	157	This suits both roles of Internet agents, that is, as either network-aware entities or (network-unaware) local agents.
158		-
	158	+<p/>
159	159	**Space**: [[#tucson() Home>>TuCSoN.WebHome]]
160	160	<br/>
161	161	**Contact**: [[Stefano Mariani>>StefanoMariani.WebHome]]
...	...	@@ -164,7 +164,7 @@
164	164
165	165	(% class="imgfloatleft" %)((([[image:2p-logo.png||height="109" width="100" align="left"]])))
166	166	#tuprolog() is a Java-based light-weight Prolog for Internet applications and infrastructures. For this purpose, #tuprolog() is designed to feature some interesting qualities: it is //easily deployable//, just requiring the presence of a Java VM and an invocation upon a single JAR file; its core is both //minimal//, taking the form of a tiny Java object containing only the most essential properties of a Prolog engine, and //configurable//, thanks to the loading and unloading of predicates, functors and operators embedded in libraries; the //integration between Prolog and Java// is as wide, deep, clean as possible; finally, //interoperability// is developed along the two main lines of Internet standard patterns and coordination models.
167		-
	167	+<p/>
168	168	**Space**: [[#tuprolog() Home>>Tuprolog.WebHome]]
169	169	<br/>
170	170	**Contact**: [[Enrico Denti>>EnricoDenti.WebHome]]