fast protocol transition in a distributed environment (brief announcement)  adaptivity is a desired feature of the distributed systems. because many characteristics of the environment (network topology, active process distribution, etc.) may change from time to time, a good system should be able to adapt itself and perform sufficiently well under different conditions.  modern distributed systems are generally built from a set of components. such a system has the freedom to adapt itself by switching from using one component to another. because most components in the distributed systems are running protocols, an agreement must be achieved among the processes when doing the adaptation.  the traditional approach to do the protocol switch is by using the two-phase- commit algorithm, in which a coordinator first broadcasts a "prepare" message, and all the other processes pause their work and send back acknowledgments. each process is buffering messages from its own application at this point. after the coordinator receives all the acknowledgments, it broadcasts a "switch" message, and upon receiving which all the processes resume working using the new configuration. this approach is clean and easy to implement. however, it has two shortcomings: (1) the reconfiguration is not "smooth", i.e.,, the overhead is large; (2) it is not scalable due to the centralized scheme.  we propose a method which allows the protocol switch with very little overhead. it is scalable as well. the method is based on the fact that if two protocols p1 and p2 are derived from the same abstract specification as, there exist converting functions and ′ that can convert the local state of a process in one protocol to another. we can then build a hybrid protocol based on p1, p2, and ′ that can make smooth adaptation at runtime.  we briefly describe the generic algorithm of the hybrid protocol in three steps: (1) one process initiates the protocol switch by broadcasting a "switch" message; (2) when a process learns about the switching, it stops the current protocol by starting buffering application messages. it then sends out its information that other processes may need in order to convert their local states; (3) when a process gets all the needed information, it converts its local state to that of the new protocol using the converting function provided. it then starts working using the new protocol immediately. each configuration is associated with a timestamp, which is tagged to the messages sent in that configuration. when a message with a timestamp greater than the local timestamp arrives, it gets buffered, and is processed after the local conversion finishes. to ensure that there is only one reconfiguration at any time, a token mechanism is being used. the hybrid protocol is smooth, because the protocol switch is not depend on the slowest process as in the two-phase- commit approach. it is efficient because the local state conversion saves many unnecessary memory operations.  as an example, we apply our algorithm to two types of atomic broadcast protocols, namely, sequencer (s-)protocol and token (t-)protocol. in the s-protocol, each process has a buffer (sbu ) holding the messages yet to be ordered by the sequencer. in the t-protocol, each process has a buffer (tbu ) holding the messages to be broadcast when the token arrives. when switching from s-protocol to t-protocol, the sequencer sends out the information including the number of the messages from each process that have been ordered so far. other processes convert by transferring the unordered messages from sbu to tbu . when switching from t-protocol to s-protocol, the process with the token sends the ordered information to the sequencer, and all the processes will transfer the messages in tbu to sbu by sending the message proposals to the sequencer.  we implement the algorithm with our group communication toolkit. the following table shows the performance of the hybrid protocol (hy b) versus that of the two-phase- commit protocol (2pc). in the test, each process broadcasts 100 messages in each round, when a process receives all the messages in this round, it starts a new round. we switch the protocol every 3 rounds. the result being shown (in msec/round) is the average round latency of 100 rounds for 3 processes. the s-protocol and t-protocol data is of no protocol switch and just for the comparison. the algorithm works much better when the number of processes increases.  our algorithm provides a generic way of building efficient and scalable adaptive protocols. we believe it is a step towards the modular approach to adding new functionalities, such as adaptation, to the distributed systems.  xiaoming liu robbert van renesse