News

I was prompted to a full professor with tenure at Peking University. Thank everyone who helped during the process.

Mining Tactics for Automated Theorem Proving was accepted at ASE 2026. This paper is the first peer-reviewed publication of our new project aiming to optimizing symbolic provers with the intelligence of LLMs. We believe symbolic methods are more suitable to cope with symbolic problems compared to LLMs, but the human intelligence devoted so far is not enough to discover the most suitable symbolic methods, and we use LLMs to continue the devleopment. Through data-driven LLM-based strategy generation, our approach improves CoqHammer by more than 20% with only a small training set.

SemOpt: LLM-Driven Code Optimization via Rule-Based Analysis was accepted at TOSEM 2026. In this paper, we use an LLM to mine optimization strategies from history commits and formalize them as semgrep rules, and use these rules to find optimization opportunities in software projects and guide an LLM to perform optimization. We successfully optimized popular software projects that have been optimized by human experts for years, and some patches we generated have been accepted by developers.

HoarePrompt: Structural Reasoning About Program Correctness in Natural Language was awarded ACM SIGSOFT Distinguished Paper Award.

Reducing Cost of LLM Agents with Trajectory Reduction was accepted at FSE 2026. In this paper, we propose the first general trajectory reduction approach for reducing the cost of LLM agents by removing unnecessary contents in trajectories while retaining the reasoning capability of agents.

Accelerating Syntax-Guided Program Synthesis by Optimizing Domain-Specific Languages was accepted at POPL 2026. In this paper, we propose a new approach to automatically optimize the programming language design to accelerate program synthesis in a specific domain.

Two papers accepted at ICSE 2026. PredicateFix: Repairing Static Analysis Alerts with Bridging Predicates proposes an approach to repairing static analysis alerts, by assisting an LLM with examples retrieved based on the static analysis rules. This approach is already deployed in ZTE and received very positive feedback from developers. HoarePrompt: Structural Reasoning About Program Correctness in Natural Language proposes a new program analysis approach with natural language specifications by using LLM to perform the strongest postcondition computation in natural language, combing the natural language reasoning capability of an LLM and classic methods.

We upgraded our probabilistic fault localization approach, Fault Localization via Efficient Probabilistic Modeling of Program Semantics, with a new general probabilistic inference algorithm and new techniques enhancing the scalability. Being training-free, SmartFL outperforms existing training-free approaches (e.g., SBFL and MBFL) in terms of not only effectiveness but also efficiency, and has the SOTA performance in statement-level fault localization in Defects4J. A SmartFL: Semantics Based Probabilistic Fault Localization describes the udpated SmartFL approach, and an Belief Propagation with Local Structure and Its Applications in Program Analysis describes the new probabilistic inference algorithm.

Tunneling Through the Hill: Multi-Way Intersection for Version-Space Algebras in Program Synthesis was accepted at OOPSLA. In this paper, we propose a new way to efficiently perform intersection, a basic operation in VSA-based program synthesis.

Through a collaboration project with ByteDance, we contributed to the development of Trae Agent: An LLM-based Agent for Software Engineering with Test-time Scaling, the currently best-performing code agent in SWE-Bench Verified, by proposing a summarization technique for agent trajectories.

Grammar-Based Code Representation: Is It a Worthy Pursuit for LLMs? was accepted at ACL as a finding. In this paper, we evaluate whether our grammar-based code representation is still useful in large neural models. We found that though large models seldom make syntax errors, their performance still significantly improves when using grammar-based representation, because grammar-based representation has better correspondance to the semantics of code.

I was selected as an ACM Distinguished Member for my contributions to program repair and synthesis.

I was elected as a member of IFIP WG2.4, the working group on software implementation technology.

We have released a benchmark for algorithm synthesis, ASAC, which consists of problems from Chinese national competitive programming contests. Compared with existing benchmarks, our benchmark is not only more difficult, but also consists of logic formalizations of the problems so that the logic-based synthesis and verification is possible. The ASAC: A Benchmark for Algorithm Synthesis will appear at the demo track of FSE'24 in the next month.

Proving Functional Program Equivalence via Directed Lemma Synthesis was accepted at FM'24. This study originates from the fact that the program synthesized by our algorithm synthesziers are too complex, and cannot be automatically verified by existing verifiers. This paper identifies that the key to the proof is find useful lemmas, and these lemmas can be then synthesized by program synthesizers. Therefore, our algorithm synthesizer can be used to verify its synthesized programs. The resulted system is 21 times faster than CVC4-Ind, the SOTA verifier.

Superfusion: Eliminating Intermediate Data Structures via Inductive Synthesis was accepted at PLDI'24. In this paper, we generalize the previous Decomposition-Based Synthesis for Applying D&C-Like Algorithmic Paradigms approach into Superfusion that optimizes programs by eliminating intermediate data structures, automating the fusion procedure in functional programming. The implemented system, SuFu, not only achieves comparable performance to AutoLifter on D&C-like algorithm synthesis problems, but also significantly outperforms existing approaches on fusion optimization and structural recursive program synthesis problems.

Our The ET Program Repair Tool for Java won the first place in the most participated Java Functional Erros track in the first international competition for Automated Program Repair. ET consists of our two existing approaches: the patch validator Accelerating Patch Validation for Program Repair with Interception-Based Execution Scheduling and the patch generator Tare: Type-Aware Neural Program Repair. ET successfully repaired 6 bugs with no incorrect patch, outperforming the baseline of calling ChatGPT (LLMR) and all other participated tools.

Accelerating Patch Validation for Program Repair with Interception-Based Execution Scheduling was accepted at IEEE Transactions on Software Engineering. This paper explains the techniques we used behind our tool ExpressAPR: Efficient Patch Validation for Java Automated Program Repair Systems for fast patch validation, which is 137.1x faster than plain validation and 8.8X faster than UniAPR, the previous SOTA tool. We hope this tool could facilitate future APR research and tool development.

Cooperating with DeepSeek (a subsidiary of High-Flyer AI), my student Qihao Zhu has leaded the development of the currently best open source base LLM for code, DeepSeek-Coder. Some of the ideas in our existing research, such as presenting the related information together to help model learn language rules, have helped the development of this model. We have published a DeepSeek-Coder: When the Large Language Model Meets Programming - The Rise of Code Intelligence about the training details. Qihao is on job market (expected to graudate at this June) and we look forward to your offer.

Decomposition-Based Synthesis for Applying D&C-Like Algorithmic Paradigms was accepted at TOPLAS. This is the second published paper of our currently focused project on algorithm synthesis, following Synthesizing Efficient Memoization Algorithms, yet actually finished earlier. This paper identifies that multiple algorithm classes, such as D&C, incremental computation, segment trees, etc, have a similar structure, and proposes a new algorithm to synthesize algorithms in this class. The number of problems solved by the synthesis algorithm in our experiment is twice that of existing general synthesis algorithm, and outperforms existing semi-automatic approaches for D&C.

GrammarT5: Grammar-Integrated Pretrained Encoder-Decoder Neural Model for Code was accepted at ICSE'24. This paper applies the grammar-based decoding technique that we have been working on (L2S: a Framework for Synthesizing the Most Probable Program under a Specification, TreeGen: A Tree-Based Transformer Architecture for Code Generation, etc.) to create a pre-training model, which significantly outperforms CodeT5, the state-of-the-art at the same scale.

A Probabilistic Delta Debugging Approach for Abstract Syntax Trees was accepted at ISSRE'23. This paper is a follow-up of our Probabilistic Delta Debugging on probabilistic debugging, and builds a probabilitc model for abstract syntactic trees, enabling more efficient delta debugging for context-free languages such as programming languages.

Two papers accepted at the research track and the tool demo track of ASE'23. ExpressAPR: Efficient Patch Validation for Java Automated Program Repair Systems presents our tool for patch validation, which integrates five acceleration techniques for reducing the compilation time and testing time, and is 100x faster than plain validation and 10x faster than UniAPR, the previous SOTA tool. We hope this tool could facilitate future APR research and tool development. OrdinalFix: Fixing Compilation Errors via Shortest-Path CFL Reachability with Attribute Checking is a research paper utilizing a novel CFL-Reachability algorithm to find the minimal fixes for compiler errors.

Synthesizing Efficient Memoization Algorithms was accepted at OOPSLA'23. This is the first published paper of our currently focused project on algorithm synthesis started three years ago. Given a formal specification, algorithm synthesis aims to apply algorithmic paradigms such as D&C and dynamic programming to synthesize efficient programs. This paper focus on synthesizing dynamic programming algorithms. Another paper on synthesizing D&C and similar algorithms has also been drafted and is available on arxiv.

I received the First-Class Award on Science from the Chinese Institute of Electronics as the 1st co-winner for the research achievement "data-driven software testing and repair". This is the only first-class award in science from CIE in the domain of software in recent three years.

Improving Oracle-Guided Inductive Synthesis by Efficient Question Selection was accepted at OOPSLA'23. In this paper, we propose a new approximation model based on random semantics to efficiently select the optimal question to be asked to the oracle in OGIS, improving the performance of any OGIS program synthesis approach in both interactive and non-interactive scenarios. This is a follow-up work of our Question Selection for Interactive Program Synthesis paper.

Two papers were accepted at ICSE23. Tare: Type-Aware Neural Program Repair describes a new approach which guides neural networks to learn typing rules, and based on which we implemented a program repair approach significantly outperforming existing program repair approaches. Reliability Assurance for Deep Neural Network Architectures Against Numerical Defects is a follow-up work of our Detecting Numerical Bugs in Neural Network Architectures that not only better detects potential bugs in neural achitectures, but also confirms these potential bugs with tests and suggests fixes.

Toward Actionable Testing of Deep Learning Models was accepted at Science China Information Sciences. This is a position paper calls for actionable testing approaches for deep learning systems.

Efficient Synthesis of Method Call Sequences for Test Generation and Bounded Verification was accepted at ASE'22. In this paper, we propose a novel synthesis techniques based on the numeration of reachable heap structures for generating unit tests.

Two papers accepted at IJCAI 2022. Grape: Grammar Preserving Rule Embedding presents an neural embedding technique for grammar rules, similar to Word2Vec for words, and could be used in many downstream applications such as program generation. Different from Word2Vec, our embedding technique takes the definitions of the grammar rules into consideration, embedding both the structure and the content of the rules. Lyra: A Benchmark for Turducken-Style Code Generation presents a new program generation benchmark that requires to generate a program in two programming languages at one time.

The videos of my talk on algorithm synthesis and my tutorial on inductive program synthesis (both in Chinese) are available in the CCF digital library. Please check the invited talks page for the links.

Three papers accepted at ICSE 2022 and AAAI 2022. Fault Localization via Efficient Probabilistic Modeling of Program Semantics is our first attempt to use a probabilistic graphical model to capture program semantics to build fault localization afresh. Preferential Labeling for Unattributed Node Classification in GNNs concerns, when a classification task should be insensitive to variable names (e.g., SAT), how to represent programs in graph neural network. Improving Machine Translation Systems via Isotopic Replacement is a testing and repairing approach for machine translation.

L2S: a Framework for Synthesizing the Most Probable Program under a Specification was accepted at TOSEM. This paper presents L2S framework, which guides program synthesis with probabilities and captures the core underline ideas of many our other papers. This work started as a generalization and extension of our Precise Condition Synthesis for Program Repair at the end of 2016. In 2018 we wrapped up the initial ideas and experiment results as a Learning to Synthesize. Finally, after almost five years' work, after numerous invited talks and keynotes at workshops and conferences about L2S, and after the publications of multiple other papers based on the framework, we finally managed to publish the full L2S framework. The final paper has 44 pages excluding the appendix.

Interactive Patch Filtering as Debugging Aid was awarded IEEE TCSE Distinguished Paper Award. Thanks for the recognition.

I received the CCF-IEEE CS Young Computer Scientists Award. This award is given to at most 5 young computer scientists in China under the age of 40 each year. Thank nominators and the award committee for the nomination and recognition.

Our MODELS 2011 paper From State- to Delta-based Bidirectional Model Transformations: the Symmetric Case was awarded MODELS 2021 Most Influential Paper Award. Thanks for the recognition!

Generalizable Synthesis Through Unification was accepted at OOPSLA'21. In this paper, we borrow the concept of "Occam Learning" from the machine learning community and build the first Occam solver based on the "synthesis through unification" framework whose generalizability is theoretically guaranteed by Occam learning.

I received the second ESEC/FSE Distinguished Reviewer Award from ESEC/FSE 2021. Thanks for the recognition.

Faster Mutation Analysis with Fewer Processes and Smaller Overheads was accepted at ASE'21. This is a follow-up work of our Faster Mutation Analysis via Equivalence Modulo States paper and further improves the efficiency of mutation analysis, the analysis problem exists in many applications such as mutation testing and patch validation.

Probabilistic Delta Debugging was awarded ACM SIGSOFT Distinguished Paper Award. Thanks for the recognition.

Interactive Patch Filtering as Debugging Aid was accepted at ICSME'21. Program repair tools are usually assume to have a high precision to be useful. In this paper we show that, with proper interaction tool support, the program repair tool with a low precision can also be useful. This opens many possibilities for future program repair research, such as increasing the recall without worrying at the risk of lowering precision. This is a follow-up work of our Question Selection for Interactive Program Synthesis paper on interactive repair/synthesis.

Probabilistic Delta Debugging and A Syntax-Guided Edit Decoder for Neural Program Repair were accepted at ESEC/FSE'21. The former proposes the first delta debugging based on probabilistic modeling and significantly outperforms the classic ddmin algorithm. The latter proposes the first neural program repair approach that outperforms traditional non-neural program repair approaches.

I received the NASAC Software Innovation Award for Young Researchers and ESEC/FSE 2020 Distinguished Reviewer Award. Thanks for the recognition from the award committees and the nominators!

Guiding Dynamic Programming via Structural Probability for Accelerating Programming by Example was accepted at OOPSLA'20. Following our Learning to Synthesize that uses probability to guide enumerative search, this paper uses probability to guide FlashFill-style dynamic programming, and achieved 4x-2000x speedup over the state-of-the-art synthesizers.

Detecting Numerical Bugs in Neural Network Architectures was awarded ACM SIGSOFT Distinguished Paper Award at ESEC/FSE'20. Thanks for the recognition.

I was recognized as a distinguished reviewer by ICSE 2020. Thank all subreviewers who contributed to the reviews. Thank the ICSE organization committee for the recognition.

Detecting Numerical Bugs in Neural Network Architectures was accepted at ESEC/FSE'20. This is the second paper in our project on detecting bugs in neural network programs, following the An Empirical Study on TensorFlow Program Bugs paper.

Question Selection for Interactive Program Synthesis was accepted at PLDI'20. Unlike most existing research studies how computers answer questions from pepople, this paper studies how computers ask questions to people for program synthesis. This is the second paper in our new project on interactive program synthesis/repair, following the How to Explain a Patch: An Empirical Study of Patch Explanations in Open Source Projects paper.

TreeGen: A Tree-Based Transformer Architecture for Code Generation has been accepted as an oral paper at AAAI'20. This paper proposes a novel transformaer architecture for code generation, which outperforms our A Grammar-Based Structural CNN Decoder for Code Generation paper, the current state-of-the-art.

Detecting Floating-Point Errors via Atomic Conditions has been accepted at POPL'20. This is a follow-up work of our A Genetic Algorithm for Detecting Significant Floating-Point Inaccuracies paper to quickly find the inputs that lead to large floating-point errors.

Our ASE paper History-Guided Configuration Diversification for Compiler Test-Program Generation was awarded ACM SIGSOFT Distinguished Paper Award.

Our paper A Survey of Compiler Testing was accepted at ACM Computing Surveys.

I have received the early career award from NSFC. This is a Chinese version of the NSF career award in US, but is only given to researchers under the age of 38 and is very competitive. Among all researchers who mainly work in software engineering in China, only Dan Hao and He Jiang have received this award before.

Three papers were accepted at ASE'19. Inferring Program Transformations From Singular Examples via Big Code solves the small-sample learning problem for program transformation inference: with the help of big code, we infer a program transformation from only one example. This technique is useful in many domains such as program repair. History-Guided Configuration Diversification for Compiler Test-Program Generation is a follow-up work of our Learning to Prioritize Test Programs for Compiler Testing paper, using historical information to directly guide the generation of test programs. Combining Spectrum-Based Fault Localization and Statistical Debugging: An Empirical Study is the first empirical study that bridges two main families of fault localization: spectrum-based fault localization and statistical debugging.

Three forward-looking papers on program repair were accepted. Automated Program Repair: A Step towards Software Automation is an invited paper for discussing the future of program repair. A Manual Inspection Of Defects4j Bugs And Its Implications For Automatic Program Repair is an empirical study on possible strategies that could potentially be adopted by program repair techniques. How to Explain a Patch: An Empirical Study of Patch Explanations in Open Source Projects explores how a patch should be communicated to developers by studying how human performs the task.

I will give a keynote speech at IBF 2019 on Feb 24th, 2019 and give a lecture at ISSTA Summer School on July 16th, 2019.

Two papers were accepted at IEEE Transactions on Software Engineering. An Empirical Study of Fault Localization Families and Their Combinations provides an infrastructure for combining and evaluating fault localization techniques, in the hope to support future fault localization research. Coverage Prediction for Accelerating Compiler Testing combines coverage prediction with learning-to-test to further accelerate compiler testing.

Our paper A Grammar-Based Structural CNN Decoder for Code Generation was accepted at AAAI'19. This paper proposes a novel CNN neural structure for code generation and can be used to instantiate the framework of Learning to Synthesize.

I have been promoted to Associated Professor (with tenure). Thanks for all people who helped in this process.

Automatic Clone Recommendation for Refactoring Based on the Present and the Past was accepted at ICSME'18.

Two papers were accepted at ISSTA'18. Shaping Program Repair Space with Existing Patches and Similar Code reports our newest attempt to increase the recall of program repair after our previous attempts (Identifying Patch Correctness in Test-Based Program Repair, Precise Condition Synthesis for Program Repair) to increase the precision. An Empirical Study on TensorFlow Program Bugs is our first step to understand and support testing and debugging in deeping learning applications.

Learning to Synthesize was accepted at GI'18. This paper proposes a framework for synthesizing a program that has a high probability in a given context.

Two papers were accepted at ICSE'18. Identifying Patch Correctness in Test-Based Program Repair utilizes two new heuristic rules to identify the correctness of generated patches. Identifying Features in Forks studies the problem of understanding forks and provides an overview of features in a fork.

Our ISSTA'17 paper Faster Mutation Analysis via Equivalence Modulo States was awarded ACM Distinguished Paper Award.

Faster Mutation Analysis via Equivalence Modulo States was accepted at ISSTA'17. Many program analysis tasks require to execute many similar versions of a program, including but not limited to mutation testing, generate-and-validate program repair, mutation-based fault localization, and product line testing. Our approach accelerates these analyses by sharing the redundant executions.

Conditional Dyck-CFL Reachability Analysis for Complete and Efficient Library Summarization was accepted at ESOP'17. In this paper we propose conditional reachability summarization to enable library summarization for Dyck-CFL reachability problems, a large class of program analysis problems.

Precise Condition Synthesis for Program Repair was accepted at ICSE'17. Following our previous attempt in our Fixing Recurring Crash Bugs via Analyzing Q&A Sites to increase the precision of defect repair (less incorrect patches), in this paper we try to generate precise patches for a more general category of defects: incorrect conditions.

Learning to Prioritize Test Programs for Compiler Testing was accepted at ICSE'17. In this paper we propose the idea of "learning to test" that applies learning techniques to accelerate compiler testing.

Detecting and Fixing Precision-Specific Operations for Measuring Floating-Point Errors was accepted at FSE'16. Precision tuning is widely used in many applications. In this paper we identified a type of code where raising precision may lead to less accurate result.

We have discovered a mistake in the data presentation of our ICST paper "Empirical Evaluation of Test Coverage for Functional Programs". Unfortuately, it is already too late to update the camera-ready version, so please download the corrected version here. Compared with the published version, Figure 3 and Table II are updated, while all discussions and conclusions are the same.

PATL paper, Transforming programs between APIs with Many-to-Many Mappings, has been accepted at ECOOP'16. A full version will be uploaded soon.

Transforming programs between APIs with Many-to-Many Mappings, PATL, was conditionally accepted at ECOOP'16. PATL handles program transformation with many-to-many mappings with the idea of guided normalization. This completes our previous work on SWIN: Towards Type-Safe Java Program Adaptation between APIs.

Our Empirical Evaluation of Test Coverage for Functional Programs has been accepted at ICST'16. The paper presents the first empirical study on test coverage of functional programs.

Recently we started a new project on compiler testing. The An Empirical Comparison of Compiler Testing Techniques presents an empirical comparison of the mainstream compiler testing techniques, where we used a new method to measure test effectiveness to make the comparison possible. The Test Case Prioritization for Compilers: a Text-Vector Based Approach presents a low-cost test prioritization approach that has the potential of accelerating compiler testing, even for the non-regressional cases.

As a member of a big team on software-defined cloud management, I received the the First-Class Award on Scientific and Technological Progress, Ministry of Education, one of the most pretigeous award from Ministry fo Education, China.

Fixing Recurring Crash Bugs via Analyzing Q&A Sites was accepted at ASE'15. Within our knowledge, this is the first paper that leverages Internet resources to fix bugs. Our approach achieved high accuracy in producing correct patches, successfully avoiding the over-fitting problem in automatic bug repair.

Inner Oracles: Input-Specific Assertions on Internal States was accepted at the new idea track of ESEC/FSE'15. In this paper, we propose the novel concept of inner oracle, which asserts the inner state of one test case. We believe inner oracles are useful in many testing scenarios.

Our paper Range Fixes: Interactive Error Resolution for Software Configuration was featured on the homepage of IEEE Transactions on Software Engineering.

Our paper SWIN: Towards Type-Safe Java Program Adaptation between APIs was invited to a journal submission as one of the best papers at PEPM'15.

Two papers were accepted at ICSE'15. Safe Memory-Leak Fixing for C Programs uses a series of dataflow analyses to fix memory leaks automatically in C programs. A Genetic Algorithm for Detecting Significant Floating-Point Inaccuracies leverages FPDebug to automatically locate input that leads to large inaccuracies in floating-point programs. Both are nice pieces of work and I am proud of the students who produced them.

Range Fixes: Interactive Error Resolution for Software Configuration was accepted at IEEE Transactions on Software Engineering. This paper extends our previous Generating Range Fixes for Software Configuration with a new property on the minimality of fix units, a simplified algorithm, and new experiments on Linux.

Our paper about SWIN: Towards Type-Safe Java Program Adaptation between APIs is accepted at PEPM'15. This is our first step towards creating a transformation language for adapting programs between different APIs, following our How Does Web Service API Evolution Affect Clients?.

Recently I started to work on problems in testing and debugging of general programs, and here are two new papers. The Boosting Bug-Report-Oriented Fault Localization with Segmentation and Stack-Trace Analysis is about the automatic association of bug reports to source files, reporting two new heuristics to improve the accuracy of existing techniques. The Search-Based Inference of Polynomial Metamorphic Relations reports the first approach to automatically inferring metamorphic relations from programs.

Our project proposal on improving the quality of safety-critical software system has been approved. This five year project is supported by the young scientist fund under the national basic research program, and I am the principal investigator. The young scientist fund under the national basic research program is one of the most competitive fund for young scientists in China. Every year only 1~3 projects are granted in the area of computer science. Our project is the first one in the area of software development.

Our SmartFixer: Fixing Software Configurations based on Self-adaptive Priorities about priority-based fixing was accepted at SPLC 2013. This work enhances our ICSE'12 work about Generating Range Fixes for Software Configuration, reducing the number of options presented to the user by inferring implicit priorities from user interactions.

Our How Does Web Service API Evolution Affect Clients? on web API evolution was accepted at ICWS 2013. This is the first step of our new project on web API evolution, which, hopefully, will eventually make it easier to migrate clients for API update.

Model Synchronization Based on Triple Graph Grammars: Correctness, Completeness and Invertibility was accepted at SoSyM. This paper is the extended version of our Correctness of Model Synchronization Based on Triple Graph Grammars, which was selected as one of the best papers at MODELS'11 and we were invited to this submission.

Inferring the Data Access from the Clients of Generic APIs was accepted at ICSM'12. This paper enhanced our Inferring Meta-Models for Runtime System Data from the Clients of Management APIs work to infer code snippets as well as the schema.

Automating Presentation Changes in Dynamic Web Applications via Collaborative Hybrid Analysis was accepted at FSE'12. This paper evolves Towards Automatic Model Synchronization from Model Transformations into collaborative hybrid analysis, which is able to propagate changes in web pages back to the generation program.

I have joined Peking University faculty as an assistant professor under the "Young talents plan". This is a newly-designed position to match the tenure-track system used in North America.

Generating Range Fixes for Software Configuration was accepted at ICSE'12. This paper proposes a new type of fix, range fix, to handle the inconsistency fixing problem arised from A User Survey of Configuration Challenges in Linux and eCos. An automated algorithm for generating range fix is also given. In the sense of general inconsistency handling, range fixes introduce an interative fixing process to resolving inconsistencies, which is a complement of our existing work on Supporting Automatic Model Inconsistency Fixing.

A A User Survey of Configuration Challenges in Linux and eCos of our online survey was accepted at VaMoS'12.

I have finished my postdoc and left University of Waterloo. Now I temporarily work as an indepent researcher while waiting for a new job offer.

We have conducted an online survey about what challenges are faced by the users of modern configuration tools. The result was published here as a technical report.

I will serve as a PC member of BX 2012. Please consider submitting a papper.

From State- to Delta-based Bidirectional Model Transformations: the Symmetric Case and Correctness of Model Synchronization Based on Triple Graph Grammars were accepted at MODELS'11.

From State- to Delta-Based Bidirectional Model Transformations: the Asymmetric Case is available on line.

A Study of Non-Boolean Constraints in Variability Models of an Embedded Operating System was accepted at FOSD'11.

I have written an article about Configurator Semantics of the CDL Language. Should be useful to anyone who wants to understand the configuration aspect of eCos/CDL.

From State- to Delta-Based Bidirectional Model Transformations: the Asymmetric Case was accepted at Journal of Object Technology. This an extended version of our From State- to Delta-Based Bidirectional Model Transformations.

Synchronizing Concurrent Model Updates Based on Bidirectional Transformation was accepted at Software and Systems Modeling and is available online. This is an extended version of our Supporting Parallel Updates with Bidirectional Model Transformations paper. This version adds discussion on history ignorance law and connects it with constant complement. I recommend to read even if you have read the conference version.

Supporting Runtime Software Architecture: A Bidirectional-Transformation-Based Approach was accepted at Journal of Systems and Software and is available online. This is an extended version of our Generating Synchronization Engines between Running Systems and Their Model-Based Views paper.

Specifying Overlaps of Heterogeneous Models for Global Consistency Checking was selected as one of the two best papers in MDI'10 and will appear in the post-proceedings.

From State- to Delta-Based Bidirectional Model Transformations was invited to a journal submission as one of the four best papers in ICMT'10.

Specifying Overlaps of Heterogeneous Models for Global Consistency Checking was accepted by MDI'10.

Tolerating Inconsistency in Feature Models was accepted by LWI'10.

Inferring Meta-Models for Runtime System Data from the Clients of Management APIs and A Dynamic-Priority based Approach to Fixing Inconsistent Feature Models were accepted by MODELS'10.

From State- to Delta-Based Bidirectional Model Transformations was accepted by ICMT'10.

I have moved from the University of Tokyo to University of Waterloo as a postdoc.

Generating Synchronization Engines between Running Systems and Their Model-Based Views was selected as one of the best two papers of Models@runtime.

I have graduated from the University of Tokyo. My thesis is available A Language-based Approach to Model Synchronization in Software Engineering.

We have released a library for helping integrate the Haskell-based synchronizer into Java projects. Please refer to here for more information.

Generating Synchronization Engines between Running Systems and Their Model-Based Views was accepted by Models@runtime.

Beanbag 1.0 was released.

A new paper describing the upcoming Beanbag 1.0 language was accepted by ESEC/FSE'09.

Atenea group has released reSynch, a UML synchronization tool developed using Beanbag. Visit here for more information.

Beanbag 0.2.1 has released. Added an output to the sync command and the resync command to show only effective update on the data. Also fixed a bug with incremental synchronization.

We have published a technical report about the Beanbag language.

Our ATL-based synchronization tool has been named as SyncATL.

We have released a new version of Beanbag. The new version includes a new and easy-to-write Beanbag language, an interactive console and two example programs.

Our on-site synchronization project has been named as Beanbag. This name comes from a Japanese traditional game of the same name where the players tries to keep several beanbag consistent within a short time constraint.

Our paper is accepted by ASE 2007!