Runtime service reconfiguration is put forward as one of the means by which we may provide dependable service-oriented architectures (SOA), and more precisely, continuity in service provisioning, and robustness in the presence of change. Indeed, with the advent of wireless networks, computing environments are becoming highly dynamic. From a user-oriented point of view, this dynamics comes at the price of dependability, due to runtime variations in terms of (1) service availability, and (2) network connection/infrastructure availability, according to user/service mobility. In this context, the main focus of this thesis is to incorporate support for dynamic reconfiguration in SOA systems, in order to tolerate runtime variations and ensure continuity in service provisioning for the users. In particular, we focus on middleware support for runtime service reconfiguration. Our main contribution consists in enabling service continuity by (1) substituting a service that becomes unavailable at runtime with a semantically similar one, and (2) translating and transferring the current state of interaction to the substitute service in order to resume the execution after its interruption. The need for state translation is due to the environments' heterogeneity, since the unavailable and substitute services are not assumed to be identically implemented, nor are they identically described. However, state translation may not be sufficient to guarantee state compatibility between the substitute service and the unavailable one: in some cases, the substitute service may be compatible with an earlier state of interaction, instead of the last one. Hence, we need to invalidate a set of results performed by the unavailable service, in order to synchronize the state of the substitute service. Indeed, the execution of the substitute service may provide different results from those provided by the execution of the unavailable service. In the case of service composition, still-available services –involved in the SOA system– may be affected by the substitution due to their data dependencies with the substituted service. Thus, the middleware synchronizes the state of still-available services according to the state transferred to the substitute service. The outcome of our contribution is SIROCCO (ServIce Reconfiguration upOn serviCe unavailability and Connectivity lOss), a middleware infrastructure that enables transparent runtime reconfiguration of SOA systems upon service unavailability. The middleware discovers candidate substitute services that can be used in the place of the service that becomes unavailable. It then tries to identify the best service amongst these candidates that can be used as an actual substitute. In the best case, the selected substitute service must be such that its current state can be synchronized with the last state of the service that is substituted. In the case of service composition, the middleware also checks data dependencies with the still-available services and synchronizes their state with respect to the transferred state. The above concepts of SIROCCO are discussed along with an experimental evaluation of our prototype. Our findings show that SIROCCO provides the necessary means for achieving dynamic service reconfiguration, where the gain in close-to-seamless continuity in service provisioning outweighs the computing and communication overhead on the execution of the SOA system.