Beanbag: On-Site Synchronization by Update Propagation Yingfei Xiong 1 , Zhenjiang Hu 1,3 , Haiyan Zhao 2 , Masato Takeichi 1 , Song Hui 2 , Hong Mei 2 1 Department of Mathematical Informatics University of Tokyo, Tokyo, Japan {Yingfei Xiong,takeichi}@mist.i.u-tokyo.ac.jp 2 Key Laboratory of High Confidence Software Technologies (Peking University) Ministry of Education, Beijing, China {zhhy,songhui06,meih}@sei.pku.edu.cn 3 Information Systems Architecture Research Division / GRACE Center National Institute of Informatics, Tokyo, Japan hu@nii.ac.jp Abstract Modern development environment often presents data with complex inter- and intra-relationships. For example, UML models have intra-relationships between diagrams, and also have inter-relationships with code. When users update some part of the data, we need to propagate these updates to other parts of the data on-site to keep them con- sistent. Such on-site synchronization usually has a strict requirement on response time, and has no predefined prop- agation direction. In this paper we propose Beanbag, a novel framework for on-site synchronization, which takes updates on all data and produces new updates to make them consistent. We deduce the propagation direction from the updates, and achieve incremental synchronization by only computing on the updated part. We have successfully applied our ap- proach to several applications and have tested its perfor- mance by experiments. 1 Introduction Modern development environment often presents data with complex inter- and intra-relationships. For example, UML models have intra-relationships between diagrams or within diagrams, and also have inter-relationships with code. In many cases, such data are editable. When users up- date some part of the data, we need to transform and prop- agate the update to other part to make all data consistent. Furthermore, several parts of the data may be modified at the same time, e.g., a group of designers are working one UML design models and a group of programmers are work- ing on hu : the ⇒ implementing code simultaneously. In such situations, we need to transform and merge the updates on different parts and detect possible conflicts. For a concrete example, let us consider a simple Enter- prise JavaBeans (EJBs) modeling tool, as shown in Figure 1. The tool provides two editable views: the deployment view and the hu : the ⇒ persistent view. The deploy- ment view shows three EJBs: SignOnEJB, UserEJB, and DepartmentEJB, all of which belong to a module SignOn. The persistent attributes of UserEJB and DepartmentEJB are true, indicating they are entity beans. The persistent view lists all entity beans. Some part of the data has inter- relationship between the two views, such as module names shared in the two views. Some part of the data has intra- relationship within one view, such as the parent-child rela- tionship between modules and EJBs. When users update an element involved in these relationships, for instance, the EJB name of an entity bean on the persistent view, the sys- tem should dynamically update the EJB name of the cor- responding EJB on the deployment view. The process of propagating updates between heterogeneous data is called heterogeneous synchronization and the software compo- nents to perform such synchronization are called synchro- nizers [4]. Existing synchronizers focus on off-site synchronization. That is, they synchronize data between off-the-shelf appli- cations where these applications export their data in some intermediate formats like XML, and the synchronizers pro- duce new XML files containing synchronized data. How- ever, off-site synchronizers cannot well support the syn- chronization happened on-site within one application, like the EJB modeling tool. Not only exporting and importing