ProActive: Programming, Composing, Deploying on the Grid
An Open Source Middleware For Parallel, Distributed, Multicore Computing

ProActive Programming

The OASIS Research Team and ActiveEon Company

Version 4.0.1 2008-12-16

Contributors and Contact Information

Team Leader:

                  Denis Caromel

                  INRIA 2004, Route des Lucioles

                   BP 93


                  Sophia Antipolis Cedex


                  phone: +33 492 387 631

                  fax: +33 492 387 971


ActiveEon Team
  • Arnaud Contes (Core, Security, Debugging)

  • Christian Delbé (FT, Scheduling)

  • Emil Salageanu (IC2D, Agent)

  • Vladimir Bodnartchouk (IC2D, TimIt)

OASIS Team Past And External Important Contributors

  • Abhijeet Gaikwad (Option Pricing)

  • Abhishek-Rajeev Gupta

  • Antonio Cansado

  • Baptiste De Stefano

  • Bastien Sauvan

  • Brian Amedro (SPMD)

  • Cédric Dalmasso (Component)

  • Clement Mathieu (Core, GCM Deployment)

  • Elaine Isnard

  • Elton Mathias

  • Eric Madelaine

  • Etienne Vallette-De-Osia

  • Fabien Viale (Matlab, Scilab)

  • Fabrice Huet (Mobility, P2P)

  • Florin Bratu

  • Franca Perrina

  • Francoise Baude

  • Germain Sigety (Scheduling)

  • Guillaume Laurent

  • Guilherme Perretti Pezzi

  • Imen Filiali

  • Jean-Luc Scheefer (Scheduling)

  • Jean-Michael Guillamume

  • Johann Fradj (Scheduling)

  • Jonathan Martin

  • Julian Krzeminski

  • Kamran Qadir

  • Khan Muhammad

  • Laurent Vanni

  • Ludovic Henrio

  • Marcela Rivera

  • Mario Leyton (Skeleton)

  • Maxime Menant

  • Nicolas Dodelin

  • Olivier Helin

  • Paul Naoumenko

  • Regis Gascon

  • Tomasz Dobek

  • Vasile Jureschi (Technical Writer)

  • Viet Dong Doan

  • Vincent Cave (Legacy Wrapping)

  • Virginie Contes (OSGi, WS)

  • Yu Feng

  • Yulai Yuan

  • Zhihui Dai

  • Alexandre di Costanzo (P2P, B&B)

  • Boutheina Bennour

  • Guillaume Chazarain (DGC)

  • Julien Vayssiere (MOP, Active Objects)

  • Lionel Mestre

  • Laurent Baduel (Group Communications)

  • Matthieu Morel (Initial Component Work)

  • Nadia Ranaldo (Core, Deployment)

  • Romain Quilici

Public questions, comments, or discussions can pe posted on the ProActive public mailing list

The mailing list archive is placed at


Bugs can be posted on the ProActive Jira bug-tracking system


List of Figures
List of Examples

Part I. Introduction

Chapter 1. ProActive Overview
1.1. ProActive Programming Frameworks
1.1.1. Introduction
1.1.2. Active Objects Model
1.1.3. Implementation Language
1.1.4. Communication through typed asychronous messages
1.1.5. Programming With Components: GCM
1.1.6. Library features
Chapter 2. ProActive Installation
2.1. ProActive Installation Overview
2.1.1. Testing ProActive With The Examples
2.1.2. Developing With ProActive
2.2. ProActive Detailed Installation Steps
2.2.1. Download And Expand The Archive
2.2.2. Set the CLASSPATH for using ProActive to write applications
2.2.3. Create a java.policy File To Set Permissions
2.2.4. A simple proactive-log4j file
2.2.5. Run A Few Examples For Testing
Chapter 3. ProActive Troubleshooting
3.1. Common problems
3.2. Enabling the loggers
3.3. Domaine name resolution problems
3.4. RMI Tunneling

Part II. Guided Tour and Tutorial

Chapter 4. Introduction To The Guided Tour and Tutorial
4.1. Overview
4.2. Installation and setup
4.3. ProActive and IDEs (Eclipse, ...)
Chapter 5. ProActive Example Applications
5.1. C3D: A distributed 3D renderer
5.1.1. How to use C3D
5.2. Readers/Writers Application
5.2.1. How to use the Readers/Writers
5.3. The dining philosophers
5.3.1. How to use the philosophers application
5.4. Migration of active objects
5.4.1. How to use the penguin application
5.4.2. How to use the Penguin Controller
5.5. Chat example
5.5.1. How to run the Chat application
5.5.2. Chat migration
5.6. Integral Pi
5.6.1. Introduction
5.6.2. Initialization
5.6.3. Communication primitives
5.6.4. Running the PI example
5.7. The nbody example
5.7.1. How to run the n-body example
5.7.2. Barnes-Hut
5.8. C3D - Active Objects to Components
5.8.1. Refactoring C3D with components
5.8.2. Creating the interfaces
5.8.3. Creating the Component Wrappers
5.8.4. Component lookup and registration
5.8.5. How to run components C3D
5.8.6. Conclusion
Chapter 6. Active Object Tutorial
6.1. Simple Computation And Monitoring Agent
6.1.1. Classes Used
6.1.2. CMA Architecture and Skeleton Code
6.1.3. Proposed Work
6.1.4. Solutions and Full Code
6.2. Active Objects Lifecycle: Using InitActive and EndActive
6.2.1. Classes Used
6.2.2. Initialized CMA Architecture and Skeleton Code
6.2.3. Proposed Work
6.2.4. Solution and Full Code
6.3. Application Deployment
6.3.1. Deployment Related Concepts
6.3.2. Deployment Descriptor Files and Application Descriptor Files
6.4. Remote Monitoring Agent
6.4.1. Classes Used
6.4.2. Deployed CMA Architecture and Skeleton Code
6.4.3. Proposed Work
6.4.4. Solution and Full Code
6.5. Agent synchronization
6.5.1. Classes Used
6.5.2. Architecture and Skeleton Code
6.5.3. Proposed Work
6.5.4. Solution And Full Code
6.6. Monitoring Several Computers Using Migration
6.6.1. Classes Used
6.6.2. Design of Migratable Monitoring Agent and Skeleton Code
6.6.3. Proposed Work
6.6.4. Solution and Full Code
6.7. Groups of Monitoring Agents
6.7.1. Classes Used
6.7.2. Architecture and Skeleton Code
6.7.3. Proposed Work
6.7.4. Solution And Full Code
6.8. Monitoring Agent As A Web Service
6.8.1. Classes Used
6.8.2. Architecture and Skeleton Code
6.8.3. Proposed Work
6.8.4. Solution And Code
6.9. Primality test tutorial
6.9.1. A Sequential Version of the Primality Test
6.9.2. Architecture of the Sequential Version
6.9.3. Implementation of the Sequential Version
6.9.4. Running the Sequential Version
6.10. A Distributed Version of the Primality Test
6.10.1. Classes Used
6.10.2. Architecture of the Distributed Version
6.10.3. Solution/Full Code
6.10.4. Running the Distributed Version
6.11. A Distributed Version of the Primality Test Using the Master-Worker API
6.11.1. Classes Used
6.11.2. Architecture of the Master-Worker Version
6.11.3. Solution/Full Code
6.11.4. Running the Master-Worker Version
Chapter 7. GCM Components Tutorial
7.1. Introduction
7.2. Key features of the ProActive/GCM Implementation
7.2.1. Primitive and composite components
7.2.2. Collective Interfaces
7.2.3. Multicast Interfaces
7.2.4. Gathercast interfaces
7.2.5. ADL file
7.3. Creating and using components in a programatic way
7.3.1. The first component
7.3.2. Define an assembly
7.4. Create and use components using ADL
7.5. Creating, using and deploying components using ADL
7.6. Component interface Cardinality
7.7. Additional examples

Part III. Programming With Active Objects

Chapter 8. Active Object Definition
8.1. Overview
8.2. Active Object Structure
Chapter 9. Active Objects: Creation And Advanced Concepts
9.1. Overview
9.2. Restrictions on creating active objects
9.3. Instantiation Based Creation
9.3.1. Using PAActiveObject.newActive(...)
9.3.2. Using PAActiveObject.newActiveInParallel(...)
9.4. Object Based Creation using PAActiveObject.turnActive(...)
9.5. Active Object Creation Arguments
9.5.1. Using classname and target
9.5.2. Using Constructor Arguments
9.5.3. Using A Node
9.5.4. Using A Custom Activity
9.5.5. Using the factory pattern with Active Objects
9.5.6. Using MetaObjectFactory to customize the meta objects
9.6. Elements of an active object and futures
9.6.1. Role of the stub
9.6.2. Role of the proxy
9.6.3. Role of the body
9.6.4. Role of the instance of class Worker
9.7. Asynchronous calls and futures
9.7.1. Creation of a Future Object
9.7.2. Methods affected by futures
9.7.3. Asynchronous calls in details
9.7.4. Good ProActive programming practices
9.7.5. Lightweight failure detection
9.8. Automatic Continuation in ProActive
9.8.1. Sending Futures
9.8.2. Receiving Futures
9.8.3. Illustration of an Automatic Continuation
9.9. Data Exchange between Active Objects
Chapter 10. Typed Group Communication
10.1. Overview
10.2. Instantiation Typed Group Creation
10.3. Group representation and manipulation
10.4. Group as result of group communications
10.5. Broadcast vs Dispatching
10.6. Access By Name
10.7. Unique serialization
Chapter 11. Mobile Agents And Migration
11.1. Migration Overview
11.2. Using Migration
11.3. Complete example
11.4. Dealing with non-serializable attributes
11.4.1. Using The MigrationStrategyManager Interface
11.4.2. Using readObject(...) and writeObject(...)
11.5. Mixed Location Migration
11.5.1. Forwarders And Agents
11.5.2. Forwarder And Agent Parameters
11.5.3. Configuration File
11.5.4. Location Server
Chapter 12. Exception Handling
12.1. Exceptions and Asynchrony
12.1.1. Barriers around try blocks
12.1.2. TryWithCatch Annotator
12.1.3. throwArrivedException() and waitForPotentialException()

Part IV. Programming With High Level APIs

Chapter 13. Master-Worker API
13.1. Overview
13.2. Logger Settings
13.3. Master Creation And Deployment
13.3.1. Local Master creation
13.3.2. Remote Master creation
13.4. Adding Resources
13.5. Tasks definition and submission
13.6. Results retrieval and reception order
13.7. Terminating the master
13.8. Worker ping period
13.9. Worker task flooding
13.10. Worker Memory
13.10.1. Structure and API
13.10.2. Storing data
13.10.3. Retrieving and using the data
13.11. Monte-Carlo PI Example
Chapter 14. The Calcium Skeleton Framework
14.1. Introduction
14.1.1. About Calcium
14.1.2. The Big Picture
14.2. Quick Example
14.2.1. Define the skeleton structure
14.2.2. Implementing the Muscle Functions
14.2.3. Create a new Calcium Instance
14.2.4. Provide an input of problems to be solved by the framework
14.2.5. Collect the results
14.2.6. View the performance statistics
14.3. Supported Patterns
14.4. Execution Environments
14.4.1. MultiThreadedEnvironment
14.4.2. ProActiveEnvironment
14.4.3. ProActiveSchedulerEnvironment (unstable)
14.5. File Access and Transfer Support (beta)
14.5.1. WorkSpace
14.5.2. Annotated Muscle Functions
14.5.3. Muscle Function Example
14.5.4. Input and Output Files from the framework
14.6. Performance Statistics (beta)
14.6.1. Global Statistics
14.6.2. Local Result Statistics
Chapter 15. OOSPMD
15.1. OOSPMD: Introduction
15.2. SPMD Group Creation
15.3. Synchronizing activities with barriers
15.3.1. Total Barrier
15.3.2. Neighbour barrier
15.3.3. Method Barrier
15.4. MPI to ProActive Summary
Chapter 16. Wrapping Application Legacy code
16.1. Simple Wrapping
16.1.1. Principles
16.1.2. API For Deploying MPI Codes
16.1.3. How to write an application with the XML and the API
16.1.4. Using the Infrastructure
16.1.5. Example with several codes
16.2. Wrapping with control
16.2.1. One Active Object per MPI process
16.2.2. MPI to ProActive Communications
16.2.3. ProActive to MPI Communications
16.2.4. MPI to MPI Communications through ProActive
16.2.5. USER STEPS - The Jacobi Relaxation example
16.3. Design and Implementation
16.3.1. Simple wrapping
16.4. Summary of the API
16.4.1. Simple Wrapping and Deployment of MPI Code
16.4.2. Wrapping with Control

Part V. Deployment And Virtualization

Chapter 17. ProActive Basic Configuration
17.1. Overview
17.2. How does it work?
17.3. Where to access this file?
17.3.1. ProActive Default Configuration file
17.3.2. User-defined ProActive Configuration file
17.3.3. Alternate User Configuration file
17.4. ProActive properties
17.4.1. Required
17.4.2. Fault-tolerance properties
17.4.3. Peer-to-Peer properties
17.4.4. rmi ssh properties
17.4.5. Other properties
17.5. Configuration file example
Chapter 18. ProActive Grid Component Model Deployment
18.1. Introduction
18.2. ProActive Deployment API
18.2.1. Resources fixed by the application (SPMD)
18.2.2. Resources fixed by the application deployer
18.2.3. On demand Scalability
18.3. GCM Deployment Descriptors
18.3.1. Host Information
18.3.2. Bridges
18.3.3. Groups
18.4. GCM Application descriptor
18.4.1. Executable
18.4.2. ProActive
18.5. FAQ
18.6. Tutorial
18.6.1. For the Grid Administrator : creating a deployment descriptor
18.6.2. For the Grid Application Developer : creating an application descriptor
18.6.3. For the Grid Application Developer : deploying your application on the grid
Chapter 19. XML Deployment Descriptors
19.1. Objectives
19.2. Principles
19.3. Different types of VirtualNodes
19.3.1. VirtualNodes Definition
19.3.2. VirtualNodes Acquisition
19.4. Different types of JVMs
19.4.1. Creation
19.4.2. Acquisition
19.5. Validation against XML Schema
19.6. Complete description and examples
19.7. Infrastructure and processes
19.7.1. Local JVMs
19.7.2. Remote JVMs
19.7.3. DependentListProcessDecorator
19.8. Infrastructure and services
19.9. How to terminate a ProActive application
19.9.1. Destroying active objects
19.9.2. Killing JVMs
19.10. Processes
Chapter 20. Variable Contracts for Descriptors
20.1. Variable Contracts for Descriptors
20.1.1. Principle
20.1.2. Variable Types
20.1.3. Variable Types User Guide
20.1.4. Variables Example
20.1.5. External Variable Definitions Files
20.1.6. Program Variable API
Chapter 21. ProActive File Transfer
21.1. Introduction and Concepts
21.2. File Transfer API
21.2.1. API Definition
21.2.2. How to use the API Example
21.3. Descriptor File Transfer
21.3.1. XML Descriptor File Transfer Tags
21.4. Advanced: FileTransfer Design
21.4.1. Abstract Definition (High level)
21.4.2. Concrete Definition (Low level)
21.4.3. How Deployment File Transfer Works
21.4.4. How File Transfer API Works
21.4.5. How Retrieve File Transfer Works
Chapter 22. Using SSH tunneling for RMI or HTTP communications
22.1. Overview
22.2. Configuration of the network
22.3. ProActive runtime communication patterns
22.4. ProActive application communication patterns.
22.5. ProActive communication protocols
22.6. The rmissh communication protocol.
Chapter 23. Technical Service
23.1. Context
23.2. Overview
23.3. Progamming Guide
23.3.1. A full XML Descriptor File
23.3.2. Nodes Properties
23.4. Further Information

Part VI. Programming With Components

Chapter 24. Introduction
24.1. Introduction
Chapter 25. Getting started
25.1. GCM Basics
Chapter 26. User guide
26.1. Architecture Description Language
26.1.1. Overview
26.1.2. Exportation and composition of virtual nodes
26.1.3. Usage
26.2. Deployment
26.3. Collective interfaces
26.3.1. Motivations
26.3.2. Multicast interfaces
26.3.3. Gathercast interfaces
26.4. Implementation specific API
26.4.1. fractal.provider
26.4.2. Requirements
26.4.3. Content and controller descriptions
26.4.4. Collective interfaces
26.4.5. Priority controller
26.4.6. Stream ports
26.5. Advanced
26.5.1. Controllers and interceptors
26.5.2. Lifecycle: encapsulation of functional activity in component lifecycle
26.5.3. Structuring the membrane with non-functional components
26.6. Short cuts
26.6.1. Principles
26.6.2. Configuration
Chapter 27. Architecture and design
27.1. Meta-object protocol
27.2. Components vs active objects
27.3. Method invocations on components interfaces
Chapter 28. Component examples
28.1. From objects to active objects to distributed components
28.1.1. Type
28.1.2. Description of the content
28.1.3. Description of the controller
28.1.4. From attributes to client interfaces
28.2. The HelloWorld example
28.2.1. Set-up
28.2.2. Architecture
28.2.3. Distributed deployment
28.2.4. Execution
28.2.5. The HelloWorld ADL files
Chapter 29. Component perspectives: a support for advanced research
29.1. Dynamic reconfiguration
29.2. Model-checking
29.3. Pattern-based deployment
29.4. Graphical tools
Chapter 30. Annex
30.1. The starter example files

Part VII. Services and Advanced Features

Chapter 31. Load Balancing
31.1. Overview
31.2. Metrics
31.2.1. MetricFactory and Metric classes
31.3. Using Load Balancing
31.3.1. In the application code
31.3.2. Technical Service
31.4. Non Migratable Objects
Chapter 32. Fault-Tolerance
32.1. Overview
32.1.1. Communication Induced Checkpointing (CIC)
32.1.2. Pessimistic message logging (PML)
32.2. Making a ProActive application fault-tolerant
32.2.1. Resource Server
32.2.2. Fault-Tolerance servers
32.2.3. Configure fault-tolerance for a ProActive application
32.2.4. A deployment descriptor example
32.3. Programming rules
32.3.1. Serializable
32.3.2. Standard Java main method
32.3.3. Checkpointing occurrence
32.3.4. Activity Determinism
32.3.5. Limitations and known bugs
32.4. A complete example
32.4.1. Description
32.4.2. Running NBody example
Chapter 33. Security Framework
33.1. Overview
33.2. Security Architecture
33.2.1. Base model
33.2.2. Security is expressed at different levels
33.3. Detailed Security Architecture
33.3.1. Nodes and Virtual Nodes
33.3.2. Hierarchical Security Entities
33.3.3. Resource provider security features
33.3.4. Interactions, Security Attributes
33.3.5. Combining Policies
33.3.6. Dynamic Policy Negotiation
33.3.7. Migration and Negotiation
33.4. How to create policy files and certificates
33.5. Activating security mechanism
33.6. The XML Security Descriptor in details
33.6.1. Construction of an XML policy:
Chapter 34. Exporting Active Objects and components as Web Services
34.1. Overview
34.2. Principles
34.3. Pre-requisite: Installing the Web Server and the SOAP engine
34.4. Steps to expose an active object or a component as a web services
34.5. Undeploy the services
34.6. Accessing the services
34.7. Limitations
34.8. A simple example: Hello World
34.8.1. Hello World web service code
34.8.2. Access with Visual Studio
34.9. C# interoperability: an example with C3D
34.9.1. Overview
34.9.2. Access with a C# client
34.9.3. Dispatcher methods calls and callbacks
Chapter 35. ProActive on top of OSGi
35.1. Overview of OSGi -- Open Services Gateway initiative
35.2. ProActive bundle and service
35.3. Yet another Hello World
35.4. Current and Future works
Chapter 36. An extended ProActive JMX Connector
36.1. Overview of JMX - Java Management eXtention
36.2. Asynchronous ProActive JMX connector
36.3. How to use the connector ?
36.4. Notifications JMX via ProActive
36.5. Example : a simple textual JMX Console
Chapter 37. Existing MBean and JMX notifications in ProActive
37.1. Principles
37.2. How to subscribe/unsubscribe to the notifications of a MBean?
37.2.1. Subscribe to the JMX notifications of a ProActive object
37.2.2. Unsubscribe to the JMX notifications
37.3. The ProActive JMX Notifications
37.3.1. How to send a JMX notification?
37.3.2. example of notification listener
37.3.3. The JMX notifications sent by the ProActive MBean

Part VIII. Extending ProActive

Chapter 38. How to write ProActive documentation
38.1. Aim of this chapter
38.2. Getting a quick start into writing ProActive doc
38.3. Example use of tags
38.3.1. Summary of the useful tags
38.3.2. Figures
38.3.3. Bullets
38.3.4. Code
38.3.5. Links
38.3.6. Tables
38.4. DocBok limitations imposed
38.5. Stylesheet Customization
38.5.1. File hierarchy
38.5.2. What you can change
38.5.3. The Bible
38.5.4. Profiling
38.5.5. The XSL debugging nightmare
38.5.6. DocBook subset: the dtd
38.5.7. Todo list, provided by Denis
38.6. Ant targets for building the documentation
38.6.1. Javadoc ant targets
38.6.2. Manual generation ant targets
Chapter 39. Developing Conventions
39.1. Code logging conventions
39.1.1. Declaring loggers name
39.1.2. Using declared loggers in your classes
39.1.3. Managing loggers
39.1.4. Logging output
39.1.5. More information about log4j
39.2. Regression Tests Writing
39.3. Committing modifications in the SVN
Chapter 40. Adding a Deployment Protocol
40.1. Objectives
40.2. Overview
40.3. Java Process Class
40.3.1. Process Package Arquitecture
40.3.2. The New Process Class
40.3.3. The StartRuntime.sh script
40.4. XML Descriptor Process
40.4.1. Schema Modifications
40.4.2. XML Parsing Handler
Chapter 41. How to add a new FileTransfer CopyProtocol
41.1. Adding external FileTransfer CopyProtocol
41.2. Adding internal FileTransfer CopyProtocol
Chapter 42. Adding a Fault-Tolerance Protocol
42.1. Overview
42.1.1. Active Object side
42.1.2. Server side
Chapter 43. MOP: Metaobject Protocol
43.1. Implementation: a Meta-Object Protocol
43.2. Principles
43.3. Example of a different metabehavior: EchoProxy
43.3.1. Instantiating with the metabehavior
43.4. The Reflect interface
43.5. Limitations

Part IX. ProActive Extra Packages / Extensions Under Development

Chapter 44. Branch and Bound API
44.1. Overview
44.2. The Model Architecture
44.3. The API Details
44.3.1. The Task Description
44.3.2. The Task Queue Description
44.3.3. The ProActiveBranchNBound Description
44.4. An Example: FlowShop
44.5. Future Work
Chapter 45. P2P Infrastructure With ProActive
45.1. Installing and Using the P2P Infrastructure
45.1.1. Create your P2P Network
45.1.2. Example of Acquiring Nodes by ProActive XML Deployment Descriptors
45.1.3. The P2P Infrastructure API Usage Example
45.2. Overview
45.3. The P2P Infrastructure Model
45.3.1. What is Peer-to-Peer?
45.3.2. The P2P Infrastructure in short
45.4. The P2P Infrastructure Implementation
45.4.1. Peers Implementation
45.4.2. Dynamic Shared ProActive Group
45.4.3. Sharing Node Mechanism
45.4.4. Monitoring: IC2D
45.5. Future Work
Chapter 46. Monte-Carlo API
46.1. Overview
46.2. API
46.2.1. Main Class
46.2.2. Tasks
46.2.3. Examples

Part X. Back matters

Appendix A. Frequently Asked Questions
A.1. Frequently Asked Questions
A.1.1. How do I build ProActive from the distribution?
A.1.2. Why don't the examples and compilation work under Windows?
A.1.3. Why do I get a Permission denied when trying to launch examples scripts under Linux?
A.1.4. How does the node creation happen?
A.1.5. How does the RMI Registry creation happen?
A.1.6. What is the class server, why do we need it?
A.1.7. What is a reifiable object?
A.1.8. What is the body of an active object? What are its local and remote representations?
A.1.9. What is a ProActive stub?
A.1.10. Are the call to an Active Object always asynchronous?
A.1.11. Why do I get an exception java.lang.NoClassDefFoundError about asm?
A.1.12. Why do I get an exception java.lang.NoClassDefFoundError about bcel?
A.1.13. Why do I get an exception java.security.AccessControlException access denied?
A.1.14. Why do I get an exception when using Jini?
A.1.15. Why do I get a java.rmi.ConnectException: Connection refused to host: ?
A.1.16. Why aren't my object's properties updated?
A.1.17. How can I pass a reference on an active object or the difference between this and PAActiveObject.getStubOnThis()?
A.1.18. How can I create an active object?
A.1.19. What are the differences between instantiation based and object based active objects creation?
A.1.20. Why do I have to write a no-args constructor?
A.1.21. How do I control the activity of an active object?
A.1.22. What happened to the former live() method and Active interface?
A.1.23. Why should I avoid to return null in methods body?
A.1.24. How can I use Jini in ProActive?
A.1.25. How do I make a Component version out of an Active Object version?
A.1.26. How can I use Jini in ProActive?
A.1.27. Why is my call not asynchronous?
A.1.28. What is the difference between passing parameters in Deployment Descriptor and setting properties in ProActive Configuration file?
A.1.29. Why do I get the following message when parsing my xml deployment file: ERROR: file:~/ProActive/descriptor.xml Line:2 Message:cvc-elt.1: Cannot find the declaration of element 'ProActiveDescriptor'
Appendix B. Reference Card
B.1. Main concepts and definitions
B.2. Main Principles: Asynchronous Method Calls And Implicit futures
B.3. Explicit Synchronization
B.4. Programming Active Objects' Activity And Services
B.5. Reactive Active Object
B.6. Service methods
B.7. Active Object Creation:
B.8. Groups:
B.9. Explicit Group Synchronizations
B.11. Migration
B.12. Components
B.13. Security:
B.14. Deployment
B.15. Exceptions
B.16. Export Active Objects as Web services
B.17. Deploying a fault-tolerant application
B.18. Peer-to-Peer Infrastructure
B.19. Branch and Bound API
B.20. File Transfer Deployment
Appendix C. Files of the ProActive source base cited in the manual
C.1. XML descriptors cited in the manual
C.2. Java classes cited in the manual
C.3. Tutorial files : Adding activities and migration to HelloWorld
C.4. Other files cited in the manual