An Efficient and Scalable Approach to Correct Class Model Refinement. Egyed, A. IEEE Transactions on Software Engineering, 35(4):515-533, 7, 2009.
abstract   bibtex   
Today, programmers benefit immensely from Integrated Development Environments (IDEs), where errors are highlighted within seconds of their introduction. Yet, designers rarely benefit from such an instant feedback in modeling tools. This paper focuses on the refinement of UML-style class models with instant feedback on correctness. Following the Model-Driven Architecture (MDA) paradigm, we strongly believe in the benefit of maintaining high-level and low-level models separately to 1) document the lower level model and 2) continuously ensure the correctness of the low-level model during later evolution (i.e., high- or low-level models may be evolved independently). However, currently the refinement and subsequent evolution lack automated support, let alone an instant feedback on their correctness (i.e., consistency). Traditional approaches to consistency checking fail here because of the computational cost of comparing class models. Our proposed instant approach first transforms the low-level model into an intermediate model that is then easier comparable with the high-level model. The key to computational scalability is the separation of transformation and comparison so that each can react optimally to changes-changes that could happen concurrently in both the high- and low-level class models. We evaluate our approach on eight third-party design models. The empirical data show that the separation of transformation and comparison results in a 6 to 11-fold performance gain and a ninefold reduction in producing irrelevant feedback. While this work emphasizes the refinement of class models, we do believe that the concepts are more generally applicable to other kinds of modeling languages, where transformation and subsequent comparison are computationally expensive.
@article{
 id = {cf20f8db-04d3-38c4-aca2-b359dbed87d3},
 title = {An Efficient and Scalable Approach to Correct Class Model Refinement},
 type = {article},
 year = {2009},
 identifiers = {[object Object]},
 keywords = {Class models,Consistency checking,Refinement,Separation of concerns and UML,UML-style class models,Unified Modeling Language,and UML.,class model refinement,computational scalability,consistency checking,integrated development environment,model-driven architecture,refinement,separation of concerns,software architecture},
 created = {2014-11-04T17:13:59.000Z},
 pages = {515-533},
 volume = {35},
 websites = {http://www.scopus.com/inward/record.url?eid=2-s2.0-68949205739&partnerID=tZOtx3y1,http://ieeexplore.ieee.org/lpdocs/epic03/wrapper.htm?arnumber=4815278},
 month = {7},
 accessed = {2014-10-29},
 file_attached = {false},
 profile_id = {6b46cd49-f8a1-3799-91ac-6861cf9a050e},
 group_id = {f76fdab6-f3b3-324f-8ded-1f7ff6220077},
 last_modified = {2014-11-15T04:19:26.000Z},
 read = {false},
 starred = {false},
 authored = {false},
 confirmed = {true},
 hidden = {false},
 short_title = {Software Engineering, IEEE Transactions on},
 abstract = {Today, programmers benefit immensely from Integrated Development Environments (IDEs), where errors are highlighted within seconds of their introduction. Yet, designers rarely benefit from such an instant feedback in modeling tools. This paper focuses on the refinement of UML-style class models with instant feedback on correctness. Following the Model-Driven Architecture (MDA) paradigm, we strongly believe in the benefit of maintaining high-level and low-level models separately to 1) document the lower level model and 2) continuously ensure the correctness of the low-level model during later evolution (i.e., high- or low-level models may be evolved independently). However, currently the refinement and subsequent evolution lack automated support, let alone an instant feedback on their correctness (i.e., consistency). Traditional approaches to consistency checking fail here because of the computational cost of comparing class models. Our proposed instant approach first transforms the low-level model into an intermediate model that is then easier comparable with the high-level model. The key to computational scalability is the separation of transformation and comparison so that each can react optimally to changes-changes that could happen concurrently in both the high- and low-level class models. We evaluate our approach on eight third-party design models. The empirical data show that the separation of transformation and comparison results in a 6 to 11-fold performance gain and a ninefold reduction in producing irrelevant feedback. While this work emphasizes the refinement of class models, we do believe that the concepts are more generally applicable to other kinds of modeling languages, where transformation and subsequent comparison are computationally expensive.},
 bibtype = {article},
 author = {Egyed, A.},
 journal = {IEEE Transactions on Software Engineering},
 number = {4}
}

Downloads: 0