Heden ten dage worden een aantal mobiele agent systemen ontworpen en geschreven aan verscheidene research labs. Deze agent systemen worden vaak nogal ad hoc benaderd, zonder grondige kennis van de aspecten die agents aanbelangen. Het blijkt dat een belangrijk onderdeel van deze systemen bestaat uit location control, ofwel het bepalen waar een agent zich op een bepaald moment bevindt. In deze thesis zullen we een mogelijk efficiënt antwoord aanreiken.

The dissertation you are about to read, tries to solve one problem within open distributed systems namely: concurrency management between components written by different manufacturers. All too often, the concurrency strategy provided or required by a component is badly documented and rarely matches the concurrency strategy provided or required by another component. Whenever this happens there is a concurrency interface conflict. Solving these conflicts requires a substantial amount of resources with respect to software engineering: the time necessary to understand the problem, the time necessary to solve the problem, and above all the resources towards maintaining a working concurrency strategy that mediates between the different components. Indeed, in open distributed systems, components can be up-dated without prior notification and without guarantees that the new interface is backward compatible. Such updates can range from syntactic modifications over slight semantic differencesto completely new concurrency strategies. For example, changing a nested locking strategy to a non-nested locking strategy or changing a non-blocking server to work synchronously. In order to solve the problem of conflicting concurrency interfaces we will create a concurrency adaptor that resolves incompatibilities between incompatible concurrency strategies. We do this in two steps: first we require a certain amount of extra information to be present: every provided and required interface should be documented by means of colored Petri-nets andcertain checkpoints are to be placed in the code to check the liveness. Second, we construct a concurrency adaptor that can be placed between the different commu-nicating components. This is done by means of a hybrid approach: first the adaptor will try to gain freedom by bypassing all the existing concurrency strategies. For a client a stub concurrency-interface is generated that will keep the client alive. For a server a stub concurrency interface is generated that will allow anything to happen; in essence bypassing the concurrency strategy en-tirely. The concurrency adaptor is finished by plugging in an existing, formally guaranteed to work concurrency strategy between the two stub concurrency interfaces. Bypassing a server's behavior is achieved by means of a runtime formal deduction. Given the current state of the Petri-net and the required state a prolog program deduces what shouldhappen.  Bypassing a clients behavior is achieved with a reinforcement learning algorithm that maximizes the reward it receives from the component itself. The rewards are based on check-points as specified by the component itself. When placing a guaranteed to work concurrency strategy between the different stub concur-rency-interfaces, we need a meta-protocol that is understood by this central concurrency strategy. This meta-protocol specifies which resources are present and which locking/unlocking opera-tions can work upon them. The meta-protocol is deduced entirely from the Petri-nets involved. The approach presented in this dissertation provides a substantial added value to the pro-grammer of components in open distributed systems. He now only needs to specify what he requires or provides as a concurrency strategy within his component. He no longer needs to takeinto account the concurrency strategy offered by other components. This might reduce development and maintenance time drastically. A second advantage of using Petri-nets is that interfacesare not only documented, but that this information can be verified automatically: whenever necessary the formal specification can be tested against the actual working of a component.