@INPROCEEDINGS{Cazzola97, author = {Massimo Ancona and Walter Cazzola and Gabriella Dodero and Vittoria Gianuzzi}, title = {{Communication Modeling by Channel Reification}}, editor = {}, booktitle = {Proceedings of the workshop ``Advances in Languages for User Modeling''}, number = {}, series = {}, year = 1997, address = {Chia Laguna, Sardinia Italia}, organization = {}, publisher = {}, pages = {1--9}, month = jun, pubtype = {workshop}, url = {http://cazzola.di.unimi.it/pubs/um97-www.pdf}, keywords = {reflection fault-tolerance}, abstract = {The paper presents a new reflective model, called Channel Reification, which can be used to implement communication abstractions. After a brief review of existing reflective models and how reflections can be used in distributed systems, channel reification is presented and compared to the widely used meta-object model. An application to protocol implementation, and hints on other channel applications are also given.}, note = {} } @INPROCEEDINGS{Cazzola98a, author = {Massimo Ancona and Walter Cazzola and Gabriella Dodero and Vittoria Gianuzzi}, title = {{Channel Reification: A Reflective Model for Distributed Computation}}, editor = {Jenevein, Roy and Obaidat, Mohammad S.}, booktitle = {Proceedings of IEEE International Performance Computing, and Communication Conference (IPCCC'98)}, number = {}, series = {}, year = 1998, address = {Phoenix, Arizona, USA}, organization = {IEEE}, publisher = {}, pages = {32--36}, month = feb, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/ipccc98-www.pdf}, keywords = {reflection fault-tolerance}, abstract = {The paper presents a new reflective model, called Channel Reification, which can be used in distributed computations to overcome difficulties experienced by other models in the literature when monitoring communication among objects. The channel is an extension of the message reification model. A Channel is a communication manager incarning successive messages exchanges by two objects: its application range between those of message reification and those of meta-object model. After a brief review of existing reflective models and how reflections can be used in distributed systems, channel reification is presented and compared to the widely used meta-object model. Applications of channel reification to protocol implementation, and to fault tolerant object systems are shown. Future extensions to this model are also summarized.}, note = {} } @INPROCEEDINGS{Cazzola98b, author = {Walter Cazzola and Andrea Savigni and Andrea Sosio and Francesco Tisato}, title = {{Architectural Reflection: Bridging the Gap Between a Running System and its Architectural Specification}}, editor = {}, booktitle = {Proceedings of 6th Reengineering Forum (REF'98)}, number = {}, series = {}, year = 1998, address = {Firenze, Italia}, organization = {IEEE}, publisher = {}, pages = {12-1--12-6}, month = mar, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/ref98-www.pdf}, keywords = {reflection sw-architecture}, abstract = {As the size and complexity of software systems increase, a relevant part of the system overall functionality shifts from the applicative domain to run-time system management activities, i.e., management activities which cannot be performed off-line. These range from monitoring to dynamic reconfiguration and, for non-stopping systems, also include evolution, i.e., addition or replacement of components or entire subsystems. In current practice, run-time system management is impeded by the fact that the knowledge of the overall structure and functioning of the system (i.e., its software architecture) is confined in design specification documents, while it is only implicit in running systems. In this paper we introduce, provide rationale for, and briefly demonstrate an approach to system management where the system maintains, and operates on, an architectural description of itself. This description is \textit{causally connected} to the system's concrete structure and state, i.e., any change of the system architecture affects the description, and vice versa. This model can be said to extend the principles of computational reflection from the realm of programming-in-the-small to that of programming-in-the-large.}, note = {} } @INPROCEEDINGS{Cazzola98c, author = {Walter Cazzola and Andrea Savigni and Andrea Sosio and Francesco Tisato}, title = {{A Fresh Look at Programming-in-the-Large}}, editor = {}, booktitle = {Proceedings of 22nd Annual International Computer Software and Application Conference (COMPSAC'98)}, number = {}, series = {}, year = 1998, address = {Wien, Austria}, organization = {IEEE}, publisher = {}, pages = {502--506}, month = aug, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/compsac98-www.pdf}, keywords = {reflection sw-architecture}, abstract = {Realizing a shift of software engineering towards a component based approach to software development requires the development of higher level programming systems supporting the development of systems from components. The paper presents a novel approach to the design of large software systems where a program in the large describing the system's architecture is executed at run time to rule over the assembly and dynamic cooperation of components. This approach has several advantages following from a clean separation of concerns between programming in the small and programming in the large issues in instantiated systems.}, note = {} } @INPROCEEDINGS{Cazzola98d, author = {Andrea Clematis and Vittoria Gianuzzi and Alexander Romanovsky and Tyrrell, Andy M. and Walter Cazzola}, title = {{Approaches to Designing Complex Dependable Systems}}, editor = {De Paoli, Flavio and Mac Leod, Ian M.}, booktitle = {Proceedings of 15th IFAC Workshop on Distributed Computer Control Systems (DCCS'98)}, number = {}, series = {IFAC Proceedings Volumes}, year = 1998, address = {Como, Italy}, organization = {IFAC}, publisher = {Elsevier}, pages = {71--78}, month = sep, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/dccs98-www.pdf}, keywords = {fault-tolerance}, abstract = {The problem of designing complex dependable systems is addressed in this paper. Due to some peculiarities of their application and behavior these are often referred to as reactive systems. Two main paradigms for their design have recently been proposed; we name these paradigms living processes and hidden concurrency, depending on their approach to concurrency handling. The analysis of application requirements and constraints is proposed as a methodology for selecting the most suitable implementation paradigm for a given application. Finally, it is shown that in some cases an intermediate paradigm may provide a suitable solution.}, note = {} } @INPROCEEDINGS{Cazzola98e, author = {Massimo Ancona and Walter Cazzola and Eduardo B. Fernandez}, title = {{Reflective Authorization Systems}}, editor = {}, booktitle = {Proceedings of ECOOP Workshop on Distributed Object Security (EWDOS'98)}, number = {}, series = {in 12th European Conference on Object-Oriented Programming (ECOOP'98)}, year = 1998, address = {Brussels, Belgium}, organization = {}, publisher = {Unit\'e de Recherche INRIA Rh\v{o}ne-Alpes}, pages = {35--39}, month = jul, pubtype = {workshop}, url = {http://cazzola.di.unimi.it/pubs/ewdos98-www.pdf}, keywords = {reflection security}, abstract = {A reflective approach for modeling and implementing authorization systems is presented. The advantages of the combined use of computational reflection and authorization mechanisms are discussed, and three reflective architectures are examined for pointing out the corresponding merits and defects.}, note = {} } @ARTICLE{Cazzola98f, author = {Massimo Ancona and Walter Cazzola}, title = {{Static Header as Sentinel}}, journal = {ACM Sigplan Notices}, year = 1998, volume = 33, number = 6, pages = {61--64}, month = jun, pubtype = {journal}, url = {http://dl.acm.org/authorize?662501}, keywords = {programming}, abstract = {Writing code to handle dynamic data structures might seem to be an easy task, but write an efficient, readable and maintainable code is not such a simple task. In this short note we investigate some problems in developing code for handling dynamic data structures, and we propose techniques to overcome them. We take into account the interesting method proposed by Qiu in SIGPLAN Notices. Many authors have addressed the problem of handling dynamic data structures by suggesting several clever tricks to simplify dynamic data structures management and to avoid the non-uniform behavior of empty data structures, and access to the first and the last element. In particular, the use of \textit{data sentinels} and \textit{dummy headers} makes the implementation more orthogonal and easy to maintain. The cost is a slightly increased size in space which is negligible when compared with the benefits produced.}, note = {} } @INPROCEEDINGS{Cazzola98g, author = {Walter Cazzola}, title = {{Evaluation of Object-Oriented Reflective Models}}, editor = {}, booktitle = {Proceedings of ECOOP Workshop on Reflective Object-Oriented Programming and Systems (EWROOPS'98)}, number = {}, series = {in 12th European Conference on Object-Oriented Programming (ECOOP'98)}, year = 1998, address = {Brussels, Belgium}, organization = {}, publisher = {}, pages = {}, month = jul, pubtype = {workshop}, url = {http://cazzola.di.unimi.it/pubs/ewroops98-www.pdf}, keywords = {reflection}, abstract = {In this paper we explore the object-oriented reflective world, performing an overview of the existing models and presenting a set of features suitable to evaluate the quality of each reflective model. The purpose of the paper is to determine the context applicability of each reflective model examined.}, note = {Extended Abstract also published on ECOOP'98 Workshop Readers, S. Demeyer and J. Bosch editors, LNCS 1543, ISBN 3-540-65460-7 pages 386-387} } @INCOLLECTION{Cazzola99a, author = {Massimo Ancona and Walter Cazzola and Eduardo B. Fernandez}, title = {{Reflective Authorization Systems: Possibilities, Benefits and Drawbacks}}, editor = {Jan Vitek and Christian Jensen}, booktitle = {{Secure Internet Programming: Security Issues for Mobile and Distributed Objects}}, series = {Lecture Notes in Computer Science 1603}, number = {}, publisher = {Springer-Verlag}, address = {}, edition = {}, month = jul, year = 1999, type = {}, chapter = {}, pages = {35-49}, pubtype = {inbook}, url = {http://cazzola.di.unimi.it/pubs/sip99-www.pdf}, keywords = {reflection security}, abstract = {We analyze how to use the reflective approach to integrate an authorization system into a distributed object-oriented framework. The expected benefits from the reflective approach are: more stability of the security layer (i.e., with a more limited number of hidden bugs), better software and development modularity, more reusability, and the possibility to adapt the security module with at most a few changes to other applications. Our analysis is supported by simple and illustrative examples written in Java.}, note = {} } @TECHREPORT{Cazzola99b, author = {Walter Cazzola and Andrea Savigni and Andrea Sosio and Francesco Tisato}, title = {{Architectural Reflection: Concepts, Design, and Evaluation}}, institution = {DSI, Universit\`a degli Studi di Milano}, type = {Technical Report}, number = {RI-DSI 234-99}, address = {}, year = 1999, month = may, pubtype = {techrep}, url = {http://cazzola.di.unimi.it/pubs/tr-dsi-234-99-www.pdf}, keywords = {reflection sw-architecture}, abstract = {This paper proposes a novel reflective approach, orthogonal to the classic computational approach, whereby a system performs computation on its \textit{software architecture} instead of individual components. The approach supports system's self-management activities such as dynamic reconfiguration to be realized in a systematic and conceptually clean way and added to existing systems without modifying the system itself. The parallelism between such \textit{architectural reflection} and classic reflection is discussed, as well as the transposition of classic reflective concepts in the architectural domain.}, note = {} } @INPROCEEDINGS{Cazzola99c, author = {Massimo Ancona and Walter Cazzola and Eduardo B. Fernandez}, title = {{A History-Dependent Access Control Mechanism Using Reflection}}, editor = {Peter Sewell and Jan Vitek}, booktitle = {Proceedings of 5th ECOOP Workshop on Mobile Object Systems (EWMOS'99)}, number = {}, series = {}, year = 1999, address = {Lisbon, Portugal}, organization = {}, publisher = {}, pages = {}, month = jun, pubtype = {workshop}, url = {http://cazzola.di.unimi.it/pubs/ewmos99-www.pdf}, keywords = {reflection security}, abstract = {We propose here a mechanism for history-dependent access control for a distributed object-oriented system, implemented using reflection. In a history-dependent access control system, access is decided based not only on the current request, but also on the previous history of accesses to some entity or service. We consider timing constraints expressed using temporal logic, and we describe a possible implementation for our mechanism. The expected benefits from the reflective approach are: more stability of the security layer (i.e., with a more limited number of hidden bugs), better software modularity, more reusability, and the possibility to adapt the security module with relatively few changes to other applications and other authorisation policies.}, note = {} } @INPROCEEDINGS{Cazzola99d, author = {Walter Cazzola and Andrea Savigni and Andrea Sosio and Francesco Tisato}, title = {{Rule-Based Strategic Reflection: Observing and Modifying Behaviour at the Architectural Level}}, editor = {}, booktitle = {Proceedings of 14th IEEE International Conference on Automated Software Engineering (ASE'99)}, number = {}, series = {}, year = 1999, address = {Cocoa Beach, Florida, USA}, organization = {}, publisher = {}, pages = {263-266}, month = oct, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/ase99-www.pdf}, keywords = {reflection sw-architecture}, abstract = {As software systems become larger and more complex, a relevant part of code shifts from the application domain to the management of the system's run-time architecture (e.g., substituting components and connectors for run-time automated tuning). We propose a novel design approach for component-based systems supporting architectural management in a systematic and conceptually clean way and allowing for the transparent addition of architectural management functionality to existing systems. The approach builds on the concept of reflection, extending it to the programming-in-the-large level, thus yielding \textit{architectural reflection} (AR). This paper focuses on one aspect of AR, namely the monitoring and dynamic modification of the system's overall control structure (strategic reflection), which allows the behaviour of a system to be monitored and adjusted without modifying the system itself.}, note = {} } @INPROCEEDINGS{Cazzola99f, author = {Walter Cazzola and Andrea Sosio and Francesco Tisato}, title = {{Reflection and Object-Oriented Analysis}}, editor = {Walter Cazzola and Robert J.\ Stroud and Francesco Tisato}, year = 1999, month = nov, booktitle = {{Proceedings of the 1st Workshop on Object-Oriented Reflection and Software Engineering (OORaSE'99)}}, publisher = {University of Milano Bicocca}, organization = {}, pages = {95-106}, pubtype = {workshop}, url = {http://cazzola.di.unimi.it/pubs/OORaSE99-www.pdf}, keywords = {reflection sw-engineering}, abstract = {Traditional methods for object-oriented analysis and modeling focus on the functional specification of software systems. Non-functional requirements such as fault-tolerance, distribution, integration with legacy systems, and the like, do not have a clear collocation within the analysis process, as they are related to the architecture and workings of the system itself rather than the application domain. They are thus addressed in the system's design, based on the partitioning of the system's functionality into classes as resulting from the analysis. As a consequence of this, the ``smooth transition from analysis to design'' that is usually celebrated as one of the main advantages of the object-oriented paradigm does not actually hold for what concerns non-functional issues. Moreover, functional and non-functional concerns tend to be mixed at the implementation level. We argue that the reflective design approach whereby non-functional properties are ascribed to a meta-level of the software system may be extended ``back to'' \textit{analysis}. Reflective Object Oriented Analysis may support the precise specification of non-functional requirements in analysis and, if used in conjunction with a reflective approach to design, recover the smooth transition from analysis to design in the case of non-functional system's properties.}, note = {} } @BOOK{Cazzola99g, editor = {Walter Cazzola and Robert J.\ Stroud and Francesco Tisato}, title = {{Proceedings of the 1st Workshop on Object-Oriented Reflection and Software Engineering (OORaSE'99)}}, year = 1999, address = {Denver, Colorado, USA}, publisher = {University of Milano Bicocca}, month = nov, pubtype = {editor}, keywords = {reflection sw-engineering}, note = {} } @BOOK{Cazzola00a, editor = {Walter Cazzola and Robert J. Stroud and Francesco Tisato}, title = {{Reflection and Software Engineering}}, volume = 1826, series = {Lecture Notes in Computer Science}, publisher = {Springer-Verlag}, address = {Heidelberg, Germany}, month = jun, pubtype = {editor}, url = {http://www.springerlink.com/content/kf03y341yc0p/}, keywords = {reflection sw-engineering}, year = 2000 } @INCOLLECTION{Cazzola00b, author = {Walter Cazzola and Andrea Sosio and Francesco Tisato}, title = {{Shifting Up Reflection from the Implementation to the Analysis Level}}, editor = {Walter Cazzola and Robert J.\ Stroud and Francesco Tisato}, booktitle = {{Reflection and Software Engineering}}, series = {Lecture Notes in Computer Science 1826}, publisher = {Springer-Verlag}, address = {Heidelberg, Germany}, edition = {}, month = jun, year = 2000, pubtype = {inbook}, url = {http://cazzola.di.unimi.it/pubs/rse00-www.pdf}, keywords = {reflection design sw-engineering}, abstract = {Traditional methods for object-oriented analysis and modeling focus on the functional specification of software systems, i.e., application domain modeling. Non-functional requirements such as fault-tolerance, distribution, integration with legacy systems, and so on, have no clear collocation within the analysis process, since they are related to the architecture and workings of the system itself rather than the application domain. They are thus addressed in the system's design, based on the partitioning of the system's functionality into classes resulting from analysis. As a consequence, the \textit{smooth transition from analysis to design} that is usually celebrated as one of the main advantages of the object-oriented paradigm does not actually hold for what concerns non-functional issues. A side effect is that functional and non-functional concerns tend to be mixed at the implementation level. We argue that the reflective approach whereby non-functional properties are ascribed to a meta-level of the software system may be extended ``back to'' analysis. Adopting a reflective approach in object-oriented analysis may support the precise specification of non-functional requirements in analysis and, if used in conjunction with a reflective approach to design, recover the smooth transition from analysis to design in the case of non-functional system's properties.}, pages = {1-20} } @TECHREPORT{Cazzola00c, author = {Walter Cazzola and Massimo Ancona}, title = {{mChaRM: a Reflective Middleware for Com\-mu\-ni\-ca\-tion-Ba\-sed Reflection}}, institution = {DISI, Universit\`{a} degli Studi di Genova}, type = {Technical Report}, number = {DISI-TR-00-09}, address = {}, year = 2000, month = may, pubtype = {techrep}, url = {}, keywords = {reflection distribution}, abstract = {}, note = {}} } @INCOLLECTION{Cazzola00d, author = {Walter Cazzola}, title = {{Communication Oriented Reflection}}, editor = {Jacques Malenfant and Sabine Moisan and Ana Moreira}, booktitle = {{ECOOP'00 Workshop Reader}}, series = {Lecture Notes in Computer Science 1964}, publisher = {Springer-Verlag}, address = {}, edition = {}, month = dec, year = 2000, pubtype = {workshop}, url = {}, keywords = {reflection distribution}, abstract = {}, pages = {287-288} } @INCOLLECTION{Cazzola00e, author = {Walter Cazzola and Shigeru Chiba and Thomas Ledoux}, title = {{Reflection and Meta-Level Architectures: State of the Art, and Future Trends}}, editor = {Jacques Malenfant and Sabine Moisan and Ana Moreira}, booktitle = {{ECOOP'00 Workshop Reader}}, series = {Lecture Notes in Computer Science 1964}, publisher = {Springer-Verlag}, address = {}, edition = {}, month = dec, year = 2000, pubtype = {report}, url = {http://cazzola.di.unimi.it/pubs/rma00-report.pdf}, keywords = {reflection}, pages = {1-15} } @INPROCEEDINGS{Cazzola00f, author = {Francesco Tisato and Andrea Savigni and Walter Cazzola and Andrea Sosio}, title = {{Architectural Reflection: Realising Software Architectures via Reflective Activities}}, editor = {Wolfang Emmerich and Stephan Tai}, booktitle = {{Proceedings of the 2nd International Workshop on Engineering Distributed Objects (EDO 2000)}}, series = {Lecture Notes in Computer Science 1999}, publisher = {Springer-Verlag}, address = {University of California, Davis, USA}, edition = {}, month = nov, year = 2000, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/edo00-www.pdf}, keywords = {reflection sw-architecture}, abstract = {Architectural reflection is the computation performed by a software system about its own software architecture. Building on previous research and on practical experience in industrial projects, in this paper we expand the approach and show a practical (albeit very simple) example of application of architectural reflection. The example shows how one can express, thanks to reflection, both functional and non-functional requirements in terms of object-oriented concepts, and how a clean separation of concerns between application domain level and architectural level activities can be enforced.}, pages = {102--115} } @INPROCEEDINGS{Cazzola00g, author = {Massimo Ancona and Walter Cazzola and Paolo Raffo and Ioan Bogdan Vasian}, title = {{Virtual Path Layout Design Via Network Clustering}}, editor = {}, booktitle = {Proceedings of International Conference Communications 2000}, number = {}, series = {}, year = 2000, address = {Bucharest, Romania}, organization = {IEEE}, publisher = {}, pages = {352-360}, month = dec, pubtype = {conference}, url = {}, keywords = {distribution fault-tolerance}, abstract = {}, note = {} } @PHDTHESIS{Cazzola00h, author = {Walter Cazzola}, title = {{Communication-Oriented Reflection: a Way to Open Up the RMI Mechanism}}, school = {Universit\`a degli Studi di Milano}, year = 2001, month = feb, address = {Milano, Italy}, pubtype = {phd}, url = {http://cazzola.di.unimi.it/pubs/phdthesis-www.pdf}, keywords = {reflection distribution}, abstract = { \textbf{The Problem}\\ From our experience, RMI-based frameworks and in general all frameworks supplying distributed computation seem to have some troubles. We detected at least three problems related to their flexibility and applicability. Most of them lack in flexibility. Their main duty consists in providing a friendly environment suitable for simply realizing distributed computations. Unfortunately, interaction policies are hardwired in the framework. If it is not otherwise foreseen, it is a hard job to change, for example, how messages are marshaled/unmarshaled, or the dispatching algorithm which the framework adopts. Some frameworks provide some limited mechanism to redefine such details but their flexibility is limited from the possibility that the designer has foreseen. Distributed algorithms are imbued in the applicative code breaking the well-known software engineering requirement termed as \textit{separation of concerns}. Some programming languages like Java mask remote interactions (i.e., remote method or procedure call) as local calls rendering their presence transparent to the programmer. However their management,~---~i.e., tuning the needed environment to rightly carry out remote computations, and synchronizing involved objects~---~is not so transparent and easily maskable to the programmer. Such a behavior hinders the distributed algorithms reuse. Object-oriented distributed programming is not distributed object-oriented programming. It is an hard job to write object-oriented distributed applications based on information managed by several separated entities. Algorithms originally designed as a whole, have to be scattered among several entities and no one of these entities directly knows the whole algorithm. This fact improves the complexity of the code that the programmer has to write because (s)he has to extend the original algorithm with statements for synchronizing and for putting in touch all the remote objects involved in the computation. Moreover the scattering of the algorithm among several objects contrasts with the object-oriented philosophy which states that data and algorithms managing them are encapsulated into the same entity, because each object can't have a global view of any data it manages, thus we could say that this approach \textit{lacks of global view}. The lack of global view forces the programmer to strictly couple two or more distributed object. A reflective approach, as stated in [Briot98], can be considered as the glue sticking together distributed and object-oriented programming and filling the gaps in their integration. Reflection improves flexibility, allows developers to provide their own solutions to communication problems, and keeps communication code separated from the application code, and completely encapsulated into the meta-level. Hence reflection could help to solve most of the troubles we detected. Reflection permits to expose implementation details of a systems, i.e., in our case allows to expose the interaction policies. It also permits to easily manipulate them. A reflective approach also permits to easily separate the interaction management from the applicative code. Using reflection and some syntactic sugar for masking the remote calls we can achieve a good separation of concerns also in distributed environments. Thanks to such considerations a lot of distributed reflective middleware have been developed. Their main goal consists both in overcoming the lacking of flexibility and in decoupling the interaction code from the applicative code. By the way, reflective distributed middlewares exhibit the same troubles detected in the distributed middlewares. They still fail in considering each remote invocation in terms of the entity involved in the communication (i.e., the client, the server, the message and so on) and not as a single entity. Hence the global view requirement is not achieved. This is due to the fact that most of the meta-models that have been presented so far and used to design the existing reflective middlewares are object-based models. In these models, every object is associated to a meta-object, which traps the messages sent to the object and implements the behavior of that invocation. Such a meta-models inherit the trouble of the lack of global view from the object-oriented methodology which encapsulates the computation orthogonally to the communication. Hence, these approaches are not appropriate to handle all the aspects of distributed computing. In particular adopting an object-based model to monitor distributed communications, the meta-programmer often has to duplicate the base-level communication graph into the meta-level augmenting the meta-program complexity. Thus, object-based approaches to reflection on communications move the well-known problem~[Videira-Lopez95] of nonfunctional code intertwined to functional one from the base- to the meta-level. Simulating a base-level communication into the meta-level allows to perform meta-computations \textit{either} related sending \textit{or} receiving action, \textit{but} not related to the whole communication or which involve information owned both by the sender and by the receiver without dirty tricks. This trouble goes under the name of \textit{global view} lacking. Besides, object-based reflective approaches and their reflective middlewares based on them allow only to carry out global changes to the mechanisms responsible for message dispatching, neglecting the management of each single message. Hence they fail to differentiate the meta-behavior related to each single exchanged message. In order to apply a different meta-behavior to either each or group of exchanged messages the meta-programmer has to write the meta-program planning a specific meta-behavior for each kind of incoming message. Unfortunately, in this way the size of the meta-program grows to the detriment of its readability, and of its maintenance. Due to such a consideration, a crucial issue of opening a RMI-based framework consists in choosing a good meta-model which permits to go around the global view lacking, and to differentiate the meta-behavior for each exchanged message. \\ \textbf{Our Solution}\\ From the problem analysis we have briefly presented we learned that in order to solve the drawbacks of the RMI-based framework we have to provide an open RMI mechanism, i.e., a reflective RMI mechanism, which exposes its details to be manipulated by the meta-program and allows the meta-program to manage each communication separately and as a single entity. The main goal of this work consists in designing such a mechanism using a reflective approach. To render the impact of reflection on object-oriented distributed framework effective, and to obtain a complete separation of concern, we need new models and frameworks especially designed for communication-oriented reflection, i.e., we need a reflective approach suitable for RMI-based communication which allows meta-programmer to enrich, manipulate and replace each remote method invocation and its semantics with a new one. That is, we need to encapsulate message exchanging into a single logical meta-object instead of scattering any relevant information related to it among several meta-objects and mimicking the real communication with one defined by the meta-programmer among such meta-objects as it is done using traditional approaches. To fulfill this commitment we designed a new model, called \textit{multi-channel reification model}. The multi-channel reification model is based on the idea of considering a method call as a message sent through a logical channel established among a set of objects requiring a service, and a set of objects providing such a service. This logical channel is reified into a logical object called \textit{multi-channel}, which monitors message exchange and enriches the underlying communication semantics with new features used for the performed communication. Each multi-channel can be viewed as an interface established among the senders and the receivers of the messages. Each multi-channel is characterized by its behavior, termed \textit{kind}, and the receivers, which it is connected to. \begin{center} multi-channel $\equiv$ (kind, receiver$_i$, \ldots, receiver$_n$)\end{center} Thanks to this multi-channel's characterization it is possible to connect several multi-channels to the same group of objects. In such a case, each multi-channel will be characterized by a different kind and will filter different patterns of messages. This model permits to design an open RMI-based mechanism which potentially overcomes the previously exposed problems. In this way, each communication channel is reified into a meta-entity. Such a meta-entity has a complete access to all details related to the communications it filters, i.e. the policies related to both the sender, and the receivers side, and, of course, the messages it filters. A channel realizes a \textit{close meta-system} with respect to the communications. It encapsulates all base-level aspect related to the communication providing the global view feature. Of course, this model keeps all the properties covered by the other reflective models, such as transparency and separation of concerns. Hence the approach also guarantees to go around the problems already solved using reflection. Protocols and other realizative stuff are exposed to the meta-programmer manipulations, and the remote method invocation management is completely separated from the applicative code. Moreover through the \textit{kind} mechanism we can differentiate the behavior which is applied to a specified pattern of messages. So a set of multi-channels (each one with a different kind) can be associated to the same communication channel. Each channel will operate to a different set of messages. In this way the channel's code is related to a unique behavior it indiscriminately has to apply to all the messages it filters. mChaRM is a framework developed by the authors which opens the RMI mechanism supplied by Java. This framework supplies a development and run-time environment based on the multi-channel reification model. Multi-channels will be developed in Java, and the underlying mChaRM framework will dynamically realize the context switching and the causal connection link. A beta version of mChaRM, documentations and examples are available from: \begin{center} \url{http://cazzola.di.unimi.it/mChaRM_webpage.html} \end{center} Such a system provided RMI-based programming environment. The supplied RMI mechanism is multi-cast (i.e., supplies a mechanism to remotely invoke a method of several servers), open (the RMI mechanism is fully customizable through reflection), and globally aware of its aspects. Some example of application are also provide. }, annote = {} } @INPROCEEDINGS{Cazzola01a, author = {Massimo Ancona and Walter Cazzola and Enrico Martinuzzi and Paolo Raffo and Ioan Bogdan Vasian}, title = {{Clustering Algorithms for the Optimization of Communication Graphs}}, editor = {}, booktitle = {Proceedings of the Fourth Conference Italo-Latino American of Industrial and Applied Mathematics}, number = {}, series = {}, year = 2001, address = {Havana, Cuba}, organization = {}, publisher = {}, pages = {328-334}, month = mar, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/itla01-www.pdf}, keywords = {fault-tolerance distribution}, abstract = {One of the main goals in optimizing communication networks is to enhance performances by minimizing the number of message hops, i.e. the number of graph nodes traversed by a message. Most of the optimization techniques are based on clustering, i.e., the network layout is reconfigured in sub-networks. Network clustering has been largely studied in the literature but most of the available algorithms are application dependent. In this paper we restrict our attention to algorithms based on the location of the median points, in order to build clusters with a balanced number of elements and to minimize communication time. We present two algorithms and relative experimental results about the quality of the computed clusterizations, in terms of the minimum number of computed hops. One algorithm is based on the well-known multi-median heuristic algorithm, while the other adopts a greedy approach, i.e., at each step the algorithm computes clusters farther and farther from each central node. To the achieved clusterization we apply a further step, which consists in finding a virtual path layout according to Gerstel's (VPPL) algorithm. The adopted criterium for our experimental comparisons is the optimality, in terms of the number of signal hops, of the achieved virtual path layout. The experiments are carried out upon a set of networks representing real environments.}, note = {}, isbn = {959-7056-13-5} } @TECHREPORT{Cazzola01b, author = {Walter Cazzola and Massimo Ancona and Fabio Canepa and Massimo Mancini and Vanja Siccardi}, title = {{Shifting Up Java RMI from P2P to Multi-Point}}, institution = {DISI, Universit\`{a} degli Studi di Genova}, type = {Technical Report}, number = {DISI-TR-01-13}, address = {}, year = 2001, month = dec, pubtype = {techrep}, url = {http://cazzola.di.unimi.it/pubs/tech-rep_disi-tr-01-13-www.pdf}, keywords = {distribution programming}, abstract = {In this paper we describe how to realize a Java RMI framework supporting multi-point method invocation. The package we have realized allows programmers to build groups of servers that could provide services in two different modes: fault tolerant and parallel. These modes differ over computations failure. Our extension is based upon the creation of entities which maintain a common state between different servers. This has been done extending the existing \textit{RMI registry}. From the user's point of view the multi-point RMI acts just like the traditional RMI system, and really the same architecture has been used.}, note = {} } @ARTICLE{Cazzola02, author = {Walter Cazzola}, title = {{mChaRM: Reflective Middleware with a Global View of Communications}}, journal = {IEEE Distributed System On-Line}, year = 2002, publisher = {IEEE}, volume = 3, number = 2, pages = {}, month = feb, ISSN = {1541-4922}, pubtype = {journal}, issn = {1541-4922}, url = {http://dsonline.computer.org/portal/site/dsonline/menuitem.9ed3d9924aeb0dcd82ccc6716bbe36ec/index.jsp?&pName=dso_level1&path=dsonline/topics/middleware/articles&file=dsonline-mcharm.xml&xsl=article.xsl&;jsessionid=J1ZhdX3xmzqNS22dRNX7T4WLLsQVDy0nvnGbkn1jsjssgxfQJhG2!1469953196}, keywords = {reflection distribution}, abstract = {The main objective of remote-method-invocation- and object-based middleware is to provide a convenient environment for the realization of distributed computations. In most cases, unfortunately, interaction policies in these middleware platforms are hardwired into the platform itself. Some platforms, e.g., CORBA's interceptors, offer means to redefine such details but their flexibility is limited to the possibilities that the designer has foreseen. In this way, distributed algorithms must be exclusively embedded in the application code, breaking any separation of concerns between functional and nonfunctional code. Some programming languages like Java disguise remote interactions as local calls, thus rendering their presence transparent to the programmer. However their management is not so transparent and easily maskable to the programmer. We can summarize these kinds of problems with current middleware platforms as follows: 1. interaction policies are hidden from the programmer who cannot customize them (lack of adaptability); 2. communication, synchronization, and tuning code is intertwined with application code (lack of separation of concerns); 3. algorithms are scattered among several objects, thus forcing the programmer to explicitly coordinate their work (lack of global view). }, note = {} } @INPROCEEDINGS{Cazzola02a, author = {Walter Cazzola and Massimo Ancona and Fabio Canepa and Massimo Mancini and Vanja Siccardi}, title = {{Enhancing Java to Support Object Groups}}, editor = {}, booktitle = {Proceedings of the Third Conference on Recent Object-Oriented Trends (ROOTS'02)}, number = {}, series = {}, year = 2002, address = {Bergen, Norway}, organization = {}, publisher = {}, pages = {}, month = apr, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/roots02-www.pdf}, keywords = {distribution programming}, abstract = {In this paper we show how to enhancing the Java RMI framework to support object groups. The package we have developed allows programmers to dynamically deal with groups of servers all implementing the same interface. Our group mechanism can be used both to improve reliability preventing system failures and to implement processor farm parallelism. Each service request dispatched to an object group returns all the values computed by the group members permitting the implementation of both kind of applications. Moreover, these approaches differ both over computations failure and over the semantic of the implemented interface. Our extension is achieved enriching the classic RMI framework and the existing \textit{RMI registry} with new functionalities. From user's point of view the multicast RMI acts just like the traditional RMI system, and really the same architecture has been used.}, note = {} } @INPROCEEDINGS{Cazzola02b, author = {Massimo Ancona and Walter Cazzola and Paolo Raffo and Marco Corvi}, title = {{Image Database Retrieval Using Wavelet Packets Compressed Data}}, editor = {}, booktitle = {Proceedings of the Sixth SIMAI National Conference}, number = {}, series = {}, year = 2002, address = {Chia Laguna, Italy}, organization = {}, publisher = {}, pages = {}, month = may, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/simai02-www.pdf}, keywords = {}, abstract = {An efficient method for cross-correlating images, in querying operations over an image database is presented. The method relies on a multiresolution compression method, based on a variant of the wavelet packets best-basis algorithm of Coifman and Wickerhauser. It is shown that a searched image can be correlated with the compressed images of the database in a fraction of the time required by using the traditional cross-correlation function computed on the original bitmap image.}, note = {} } @TECHREPORT{Cazzola02c, author = {Massimo Ancona and Walter Cazzola}, title = {{The Programming Language \textsf{Io}}}, institution = {DISI, Universit\`a degli Studi di Genova}, type = {Technical Report}, number = {DISI-TR-04-02}, address = {}, year = 2002, month = may, pubtype = {techrep}, url = {}, keywords = {dsl reflection programming}, abstract = {}, note = {} } @INPROCEEDINGS{Cazzola02d, author = {Walter Cazzola and Ahmed Ghoneim and Gunter Saake}, title = {{Reflective Analysis and Design for Adapting Object Run-time Behavior}}, editor = {Zohra Bellahs\`ene and Dilip Patel and Colette Rolland}, booktitle = {Proceedings of the 8th International Conference on Object-Oriented Information Systems (OOIS'02)}, number = {}, series = {Lecture Notes in Computer Science 2425}, year = 2002, address = {Montpellier, France}, organization = {}, publisher = {Springer-Verlag}, pages = {242-254}, month = sep, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/oois02-www.pdf}, keywords = {reflection design evolution}, abstract = {Today, complex information systems need a simple way for changing the object behavior according with changes that occur in its running environment. We present a reflective architecture which provides the ability to change object behavior at run-time by using design-time information. By integrating reflection with design patterns we get a flexible and easily adaptable architecture. A reflective approach that describes object model, scenarios and statecharts helps to dynamically adapt the software system to environmental changes. The object model, system scenario and many other design information are reified by special meta-objects, named \textit{evolutionary meta-objects}. Evolutionary meta-objects deal with two types of run-time evolution. Structural evolution is carried out by causal connection between evolutionary meta-objects and its referents through changing the structure of these referents by adding or removing objects or relations. Behavioral evolution allows the system to dynamically adapt its behavior to environment changes by itself. Evolutionary meta-objects react to environment changes for adapting the information they have reified and steering the system evolution. They provide a natural liaison between design information and the system based on such information. This paper describes how this liaison can be built and how it can be used for adapting a running system to environment changes.}, note = {}, isbn = {3-540-44087-9} } @INPROCEEDINGS{Cazzola02e, author = {Walter Cazzola and Coplien, James O. and Ahmed Ghoneim and Gunter Saake}, title = {{Framework Patterns for the Evolution of Nonstoppable Software Systems}}, editor = {Hruby, Pavel and S{\o}resen, Kristian Elof}, booktitle = {Proceedings of the 1st Nordic Conference on Pattern Languages of Programs (VikingPLoP'02)}, number = {}, series = {}, year = 2002, address = {H{\o}jstrupg\r{a}rd, Helsing{\o}r, Denmark}, organization = {}, publisher = {Microsoft Business Solutions}, pages = {35-54}, month = sep, isbn = {87-7849-769-8}, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/viking-plop02-www.pdf}, keywords = {reflection evolution design}, abstract = {The fragment of \textit{pattern language} proposed in this paper, shows how to adapt a nonstoppable software system to reflect changes in its running environment. These \textit{framework patterns} depend on well-known techniques for programs to dynamically analyze and modify their own structure, commonly called \textit{computational reflection}. Our patterns go together with common reflective software architectures.}, note = {} } @INPROCEEDINGS{Cazzola03, author = {Massimo Ancona and Walter Cazzola and Daniele D'Agostino}, title = {{Smart Data Caching in Archeological Wireless Applications: the \textsf{PAST} Solution}}, editor = {Andrea Clematis}, booktitle = {Proceedings of the 11th Euromicro Conference on Parallel, Distributed and Network-Based Processing (Euromicro PDP 2003)}, number = {}, series = {}, year = 2003, address = {Genova, Italy}, organization = {}, publisher = {IEEE Computer Society Press}, pages = {532-536}, month = feb, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/pdp03-www.pdf}, keywords = {distribution programming}, abstract = {Wireless computing, because of the limited memory capacity of the palmtops, forces to separate data (stored on a remote server) from the application (running on the palmtops) that uses them. In applications working on data that frequently change, several kilobytes of data are exchanged between the server and the client palmtops. It is fairly evident that a similar tight coupling may easily saturate the network bandwidth when many palmtops are used in parallel, thus degrading the performances of the application running on it. This paper shows a way to reduce the waste of bandwidth by exploiting at the best the palmtop memory to deal with data caching. The proposed smart data caching is based on context information. We have also applied our method and analyzed its features in a specific application: electronic guide to archeological sites in the PAST \textsf{EC IT} project.}, note = {}, isbn = {0-7695-1875-3} } @TECHREPORT{Cazzola03b, author = {Dario Maggiorini and Walter Cazzola and B.S. Prabhu and Rajit Gadh}, title = {{A Service-Oriented Middleware for Seamless Nomadic System-Aware (SNA) Servants}}, institution = {WINMEC: Wireless INternet for the Mobile Enterprise Consortium}, type = {White Paper}, number = {}, address = {}, year = 2003, month = mar, pubtype = {techrep}, url = {http://www.wireless.ucla.edu/winmec/projects/SNA_Servants.pdf}, keywords = {distribution reflection}, abstract = {In the last few years there has been a considerable penetration of wireless technology in everyday life. This penetration has also increased the availability of \textit{Location-Dependent Information Service}s (LDIS), such as local information access (e.g. traffic reports, news, etc.), nearest-neighbor queries (such as finding the nearest restaurant, gas station, medical facility, ATM, etc.) and others. New wireless environments and paradigms are continuously evolving and novel LDISs are continuously being deployed. Such a growth means the need to deal with: \begin{itemize} \item services without standard interfaces - same or similar LDISs being offered by different vendors through different APIs but with same standard functional interfaces; \item services deployed dynamically - LDIS made available on a need basis or when the scenario dynamically mutates and in addition provides dynamic roaming between services and dynamic service interchangeability; and \item non-classified services (i.e., novel services). \end{itemize} }, note = {} } @ARTICLE{Cazzola03c, author = {Walter Cazzola}, title = {{Remote Method Invocation as a First-Class Citizen}}, journal = {Distributed Computing}, publisher = {Springer-Verlag}, year = 2003, volume = 16, number = 4, pages = {287-306}, month = dec, issn = {0178-2770}, doi = {10.1007/s00446-003-0094-8}, pubtype = {journal}, url = {http://cazzola.di.unimi.it/pubs/dc03-www.pdf}, keywords = {reflection distribution}, abstract = {The classical \textit{remote method invocation} (RMI) mechanism adopted by several object-based middleware is `black box' in nature, and the RMI functionality, i.e., the RMI interaction policy and its configuration, is hard-coded into the application. This RMI nature hinders software development and reuse, forcing the programmer to focus on communication details often marginal to the application he is developing. Extending the RMI behavior with extra functionality is also a very difficult job, because added code must be scattered among the entities involved in communications. This situation could be improved by developing the system in several separate layers, confining communications and related matters to specific layers. As demonstrated by recent work on reflective middleware, reflection represents a powerful tool for realizing such a separation and therefore overcoming the problems referred to above. Such an approach improves the separation of concerns between the communication-related algorithms and the functional aspects of an application. However, communications and all related concerns are not managed as a single unit separate from the rest of the application, which makes their reuse, extension and management difficult. As a consequence, communications concerns continue to be scattered across the meta-program, communication mechanisms continue to be black-box in nature, and there is only limited opportunity to adjust communication policies through configuration interfaces. In this paper we examine the issues raised above, and propose a reflective approach especially designed to open up the Java RMI mechanism. Our proposal consists of a new reflective model, called \textit{multi-channel reification}, that reflects on and reifies communication channels, i.e., it renders communication channels first-class citizens. This model is designed both for developing new communication mechanisms and for extending the behavior of communication mechanisms provided by the underlying system. Our approach is embodied in a framework called mChaRM which is described in detail in this paper.}, note = {} } @INPROCEEDINGS{Cazzola04, author = {Walter Cazzola and Dario Maggiorini}, title = {{Seamless Nomadic System-Aware Servants}}, editor = {Sprague, Jr, Ralph H.}, booktitle = {Proceedings of the 37th Hawai'i International Conference on System Sciences (HICSS'04)}, number = {}, series = {}, year = 2004, address = {Big Island, Hawaii}, organization = {}, publisher = {IEEE Computer Society Press}, pages = {}, month = jan, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/hicss04-www.pdf}, keywords = {distribution reflection}, abstract = {The growing diffusion of wireless technologies is leading to deployment of small-scale and location dependent information services (LDISs). Those new services call for provisioning schemes that are able to operate in a distributed environment and do not require network infrastructure. This paper describes an approach to a service-oriented middleware which enables a mobile device to be aware of the surrounding environment and to transparently exploit every LDIS discovered in the coverage area of the hosting wireless network. the paper introduces seamless nomadic system-aware (SNA) servant. SNA servants run on mobile devices, discover LDISs and are not associated with any specific service. The paper also describes the key features for the SNA servants implementation and for rendering them interoperable and cross-platform on, at least, \dotnet and \textsf{JVM} frameworks.}, note = {} } @INPROCEEDINGS{Cazzola04b, author = {Walter Cazzola}, title = {{SmartMethod: an Efficient Replacement for Method}}, editor = {}, booktitle = {Proceedings of the 9th Annual ACM Symposium on Applied Computing (SAC'04)}, number = {}, series = {}, year = 2004, address = {Nicosia, Cyprus}, organization = {}, publisher = {ACM Press}, pages = {1305-1309}, month = mar, pubtype = {conference}, url = {http://dl.acm.org/authorize?705838}, keywords = {reflection programming}, abstract = {In the last few years the interest in reflection has grown and many modern programming languages/architectures have provided the programmer with reflective mechanisms. As well as any other novelty also reflection has detractors. They rightly or wrongly accuse reflection to be too inefficient to be used with real profit. In this work, we have investigated about the performance of Java reflection library (especially of the class \texttt{Method} and of its method \texttt{invoke}) and realized a mechanism which improves its performances. Our mechanism consists of a class, named \texttt{SmartMethod} and of a parser contributing to transform reflective invocations into direct call carried out by the standard invocation mechanism of Java. The \texttt{SmartMethod} class is compliant ---~that is, it provides exactly the same services~---, with the class \texttt{Method} of the standard Java core reflection library but it provides a more efficient reflective method invocation.}, note = {} } @INPROCEEDINGS{Cazzola04c, author = {Massimo Ancona and Walter Cazzola}, title = {{Implementing the Essence of Reflection: a Reflective Run-Time Environment}}, editor = {}, booktitle = {Proceedings of the 9th Annual ACM Symposium on Applied Computing (SAC'04)}, number = {}, series = {}, year = 2004, address = {Nicosia, Cyprus}, organization = {}, publisher = {ACM Press}, pages = {1503-1507}, month = mar, pubtype = {conference}, url = {http://dl.acm.org/authorize?705272}, keywords = {reflection}, abstract = {Computational reflection provides the developers with a programming mechanism devoted to favorite code extensibility, reuse and maintenance. Notwithstanding that, it has not achieved developers' unanimous acceptance and its full potential yet. In our opinion, this depends on the intrinsic complexity of most of the reflective approaches that hinders their efficient implementation. The aim of this paper consists of defining the essence of reflection, that is, to identify the minimal set of characteristics that a software system must have to be considered reflective. The consequence is the realization of a run-time environment supporting the essence of reflection without affecting the programming language and with a minimal impact on the programming system design. This achievement will improve reflective system performances reducing the impact of one of the most diffuse criticism about reflection: low performance.}, note = {} } @INCOLLECTION{Cazzola04d, author = {Walter Cazzola and Ahmed Ghoneim and Gunter Saake}, title = {{Software Evolution through Dynamic Adaptation of Its OO Design}}, editor = {Ehrich, Hans-Dieter and Meyer, John-Jules and Ryan, Mark D.}, booktitle = {{Objects, Agents and Features: Structuring Mechanisms for Contemporary Software}}, series = {Lecture Notes in Computer Science 2975}, publisher = {Springer-Verlag}, address = {}, edition = {}, month = jul, year = 2004, pubtype = {inbook}, url = {http://cazzola.di.unimi.it/pubs/oaf04-www.pdf}, keywords = {reflection evolution design}, abstract = {In this paper we present a proposal for safely evolving a software system against run-time changes. This proposal is based on a reflective architecture which provides objects with the ability of dynamically changing their behavior by using their design information. The meta-level system of the proposed architecture supervises the evolution of the software system to be adapted that runs as the base-level system of the reflective architecture. The meta-level system is composed of cooperating components; these components carry out the evolution against sudden and unexpected environmental changes on a reification of the design information (e.g., object models, scenarios and statecharts) of the system to be adapted. The evolution takes place in two steps: first a meta-object, called \textit{evolutionary meta-object}, plans a possible evolution against the detected event then another meta-object, called \textit{consistency checker meta-object} validates the feasibility of the proposed plan before really evolving the system. Meta-objects use the system design information to govern the evolution of the base-level system. Moreover, we show our architecture at work on a case study.}, pages = {69-84} } @INPROCEEDINGS{Cazzola04e, author = {Alberto Traverso and Massardo, Aristide F. and Walter Cazzola and Giovanni Lagorio}, title = {{WIDGET-TEMP: A Novel Web-Based Approach for Thermoeconomic Analysis and Optimization of Conventional and Innovative Cycles}}, booktitle = {{ASME Proceedings}}, year = 2004, editor = {}, pages = {623-631}, address = {Vienna, Austria}, organization = {}, publisher = {IEE}, volume = 7, number = {}, series = {}, month = jun, ISBN = {0-7918-4172-3}, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/asme04-www.pdf}, keywords = {web}, abstract = {In a deregulated energy market the adoption of multipurpose and flexible software tools for the optimal design and sizing of energy systems is becoming mandatory. For these reasons, we have developed WIDGET-TEMP (Web-based Interface and Distributed Graphical Environment for TEMP, ThermoEconomic Modular Program), a tool which is the result of an interdisciplinary research which applied recent IT innovations such as XML and web-based approaches to the analysis and optimization of energy plant layouts on a thermoeconomic basis. WIDGET provides an interface for remotely accessing the internal thermoeconomic analysis, the full life-cycle cost and investment assessment, which includes the economic impact of environmental costs due to pollutant emissions. This approach reduces the requirements for the local machine in terms of processor time and memory, and allows users to exploit the tool just when needed. An initial functional productive diagram of the plant is now automatically drawn and is available to the user on a visual basis. We present a general description of the tool organization and outline the approach for modeling the technical performance and cost of the component. Then, we describe the latest upgrades of TEMP, and report the new gas turbine cost equations. Finally, the tool is applied to a conventional simple and combined cycle, showing both the usability of the new tool and the reliability of the results.}, note = {Paper No. GT2004-54115} } @INPROCEEDINGS{Cazzola04f, author = {Walter Cazzola and Ahmed Ghoneim and Gunter Saake}, title = {{System Evolution through Design Information Evolution: a Case Study}}, editor = {Walter Dosch and Narayan Debnath}, booktitle = {Proceedings of the 13th International Conference on Intelligent and Adaptive Systems and Software Engineering (IASSE 2004)}, number = {}, series = {}, year = 2004, address = {Nice, France}, organization = {}, publisher = {ISCA}, pages = {145-150}, month = jul, isbn = {1-880843-52-x}, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/iasse04-www.pdf}, keywords = {reflection evolution design}, abstract = {This paper describes how design information, in our case \uml specifications, can be used to evolve a software system and validate the consistency of such an evolution. This work complements our previous work on reflective architectures for software evolution describing the role played by meta-data in the evolution of software systems. The whole paper focuses on a case study; we show how the \textit{urban traffic control system} (UTCS) or part of it must evolve when unscheduled road maintenance, a car crush or a traffic jam block normal vehicular flow in a specific road. The UTCS case study perfectly shows how requirements can dynamically change and how the design of the system should adapt to such changes. Both system consistency and adaptation are governed by rules based on meta-data representing the system design information. As we show by an example, such rules represent the core of our evolutionary approach driving the \textit{evolutionary} and \textit{consistency checker meta-objects} and interfacing the meta-level system (the evolutionary system) with the system that has to be adapted.}, note = {} } @INPROCEEDINGS{Cazzola04g, author = {Walter Cazzola and Sonia Pini and Massimo Ancona}, title = {{Evolving Pointcut Definition to Get Software Evolution}}, editor = {}, booktitle = {Proceedings of the 1st ECOOP Workshop on Reflection, AOP and Meta-Data for Software Evolution (RAM-SE'04)}, number = {}, series = {}, year = 2004, address = {Oslo, Norway}, organization = {}, publisher = {}, pages = {83-88}, month = jun, pubtype = {workshop}, url = {http://cazzola.di.unimi.it/pubs/ramse04-www.pdf}, keywords = {AOP evolution}, abstract = {In this paper, we have briefly analyzed the aspect-oriented approach with respect to the software evolution topic. The aim of this analysis is to highlight the aspect-oriented potentiality for software evolution and its limits. From our analysis, we can state that actual pointcut definition mechanisms are not enough expressive to pick out from design information where software evolution should be applied. We will also give some suggestions about how to improve the pointcut definition mechanism.}, note = {} } @INPROCEEDINGS{Cazzola04h, author = {Walter Cazzola and Ahmed Ghoneim and Gunter Saake}, title = {{RAMSES: a Reflective Middleware for Software Evolution}}, editor = {}, booktitle = {Proceedings of the 1st ECOOP Workshop on Reflection, AOP and Meta-Data for Software Evolution (RAM-SE'04)}, number = {}, series = {}, year = 2004, address = {Oslo, Norway}, organization = {}, publisher = {}, pages = {21-26}, month = jun, pubtype = {workshop}, url = {http://cazzola.di.unimi.it/pubs/ram-se04-www.pdf}, keywords = {reflection evolution design}, abstract = {Software systems today need to dynamically self-adapt against dynamic requirement changes. In this paper we describe \ramses a reflective middleware whose aim consists of consistently evolving software systems against runtime changes. This middleware provides the ability to change both structure and behavior for the base-level system at run-time by using its design information. The meta-level is composed of cooperating objects, and has been specified by using a design pattern language. The base objects are controlled by meta-objects that drive their evolution. The essence of \ramses is the ability of extracting the design data from the base application, and of constraining the dynamic evolution to stable and consistent systems.}, note = {} } @INPROCEEDINGS{Cazzola04i, author = {Massimo Ancona and Walter Cazzola and Sara Drago and Francesco Guido}, title = {{An XML-Based Description of Structured Networks}}, editor = {}, booktitle = {Proceedings of International Conference Communications 2004}, number = {}, series = {}, year = 2004, address = {Bucharest, Romania}, organization = {IEEE Press}, publisher = {}, pages = {401-406}, month = jun, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/communications04-www.pdf}, keywords = {programming}, abstract = {In this paper we present an \xml-based formalism to describe hierarchically organized communication networks. After a short overview of existing graph description languages, we discuss the advantages and disadvantages of their application in network optimization. We conclude by extending one of these formalisms with features supporting the description of the relationship between the optimized logical layout of a network and its physical counterpart. Elements for describing traffic parameters are also given.}, note = {} } @BOOK{Cazzola04l, editor = {Walter Cazzola and Shigeru Chiba and Gunter Saake}, title = {{Proceedings of the 1st ECOOP Workshop on Reflection, AOP and Meta-Data for Software Evolution (RAM-SE'04)}}, year = 2004, series = {Research Report C-196 of the Dept. of Mathematical and Computing Sciences, Tokyo Institute of Technology}, address = {}, month = jul, pubtype = {editor}, url = {http://cazzola.di.unimi.it/RAM-SE proceedings/RAM-SE04 Proceedings.pdf}, keywords = {reflection evolution AOP meta-data}, publisher = {Preprint No. 10/2004 of Fakult\"{a}t f\"{u}r Informatik, Otto-von-Guericke-Universit\"{a}t Magdeburg} } @INCOLLECTION{Cazzola04m, author = {Walter Cazzola and Shigeru Chiba and Gunter Saake}, title = {{Software Evolution: a Trip through Reflective, Aspect, and Meta-Data Oriented Techniques}}, editor = {Malenfant, Jacques and {\O}stvold, Bjarte M.}, booktitle = {{ECOOP'04 Workshop Reader}}, series = {Lecture Notes in Computer Science 3344}, publisher = {Springer-Verlag}, address = {}, edition = {}, month = dec, year = 2004, pubtype = {report}, url = {http://cazzola.di.unimi.it/pubs/ramse04-report.pdf}, keywords = {reflection evolution meta-data AOP}, pages = {116-130} } @ARTICLE{Cazzola04n, author = {Walter Cazzola}, title = {{SmartReflection: Efficient Introspection in Java}}, journal = {Journal of Object Technology}, publisher = {}, year = 2004, volume = 3, number = 11, pages = {117-132}, month = dec, ISSN = {}, pubtype = {journal}, url = {http://cazzola.di.unimi.it/pubs/jot04-www.pdf}, keywords = {reflection programming}, abstract = {In the last few years the interest in reflection has grown and many modern programming languages/environments (e.g., Java and .NET) have provided the programmer with reflective mechanisms, i.e., with the ability of dynamically looking into (introspect) the structure of the code from the code itself. In spite of its evident usefulness, reflection has many detractors, who claim that it is too inefficient to be used with real profit. In this work, we have investigated about the performance issue in the context of the Java reflection library and presented a different approach to the introspection in Java that improves its performances. The basic idea of the proposed approach consists of moving most of the overhead due to the dynamic introspection from run-time to compile-time. The efficiency improvement has been proved by providing a new reflection library compliant --~that is, it provides exactly the same services~--, with the standard Java reflection library based on the proposed approach. This paper is focused on speeding up the reification and the invocation of methods, i.e., on the class \texttt{SmartMethod} that replaces the class \texttt{Method} of the standard reflection library. }, note = {} } @INPROCEEDINGS{Cazzola04o, author = {Massimo Ancona and Walter Cazzola and Sonia Pini and Marco Frascio and Natasha Stavropoulou and Alex Conconi}, title = {{Doc at Hand: Knowledge Sharing and Decision Support for Healthcare Professionals}}, editor = {}, booktitle = {Proceedings of 1st Euro-Mediterranean Conference on Medical Informatics and Telemedicine (EMMIT'04)}, number = {}, series = {}, year = 2004, address = {Genova, Italia}, organization = {}, publisher = {}, pages = {}, month = nov, pubtype = {conference}, url = {}, keywords = {e-health}, abstract = {}, note = {} } @INPROCEEDINGS{Cazzola05, author = {Walter Cazzola and Antonio Cisternino and Diego Colombo}, title = {{[a]C\#: C\# with a Customizable Code Annotation Mechanism}}, editor = {}, booktitle = {Proceedings of the 10th Annual ACM Symposium on Applied Computing (SAC'05)}, number = {}, series = {}, year = 2005, address = {Santa Fe, New Mexico, USA}, organization = {}, publisher = {ACM Press}, pages = {1274-1278}, month = mar, pubtype = {conference}, url = {http://dl.acm.org/authorize?869741}, keywords = {reflection meta-data}, abstract = {Reflective programming is becoming popular due to the increasing set of dynamic services provided by execution environments like JVM and CLR. With custom attributes Microsoft introduced an extensible model of reflection for CLR: they can be used as additional decorations on element declarations. The same notion has been introduced in Java 1.5. The extensible model proposed in both platforms limits annotations to class members. In this paper we describe [a]C#, an extension of the C# programming language, that allows programmers to annotate statements or code blocks and retrieve these annotations at run-time. We show how this extension can be reduced to the existing model. A set of operations on annotated code blocks to retrieve annotations and manipulate bytecode is introduced. Finally, we discuss how to use [a]C# to annotate programs giving hints on how to parallel a sequential method and how it can be implemented by means of the abstractions provided by the run-time of the language.}, note = {} } @INPROCEEDINGS{Cazzola05b, author = {Walter Cazzola and Sonia Pini and Massimo Ancona}, title = {{AOP for Software Evolution: A Design Oriented Approach}}, editor = {}, booktitle = {Proceedings of the 10th Annual ACM Symposium on Applied Computing (SAC'05)}, number = {}, series = {}, year = 2005, address = {Santa Fe, New Mexico, USA}, organization = {}, publisher = {ACM Press}, pages = {1356-1360}, month = mar, pubtype = {conference}, url = {http://dl.acm.org/authorize?869866}, keywords = {AOP evolution design}, abstract = {In this paper, we have briefly explored the aspect-oriented approach as a tool for supporting the software evolution. The aim of this analysis is to highlight the potentiality and the limits of the aspect-oriented development for software evolution. From our analysis follows that in general (and in particular for AspectJ) the approach to join points, pointcuts and advices definition are not enough intuitive, abstract and expressive to support all the requirements for carrying out the software evolution. We have also examined how a mechanism for specifying pointcuts and advices based on design information, in particular on the use of UML diagrams, can better support the software evolution through aspect oriented programming. Our analysis and proposal are presented through an example.}, note = {} } @INPROCEEDINGS{Cazzola05k, author = {Ancona, Massimo and Pini, Sonia and Cazzola, Walter and Frascio, Marco and Simonov, Mikhail and Sammartino, Luca}, title = {{Knowledge Sharing and Decision Support System for Healthcare Professionals}}, booktitle = {{Proceedings of the International Trade Event and Conference for eHealth, Telemedicine and Health ICT (Med-e-Tel 2005)}}, year = 2005, editor = {}, pages = {}, address = {Luxembourg City, Luxembourg}, organization = {}, publisher = {}, volume = {}, number = {}, series = {}, month = apr, pubtype = {conference}, url = {}, keywords = {e-health}, abstract = {}, note = {} } @INPROCEEDINGS{Cazzola05c, author = {Walter Cazzola and Sonia Pini and Massimo Ancona}, title = {{The Role of Design Information in Software Evolution}}, editor = {Cazzola, Walter and Chiba, Shigeru and Saake, Gunter and Tourw\'e, Tom}, booktitle = {Proceedings of the 2nd ECOOP Workshop on Reflection, AOP and Meta-Data for Software Evolution (RAM-SE'05)}, number = {}, series = {}, year = 2005, address = {Glasgow, Scotland}, organization = {}, publisher = {}, pages = {59-70}, month = jul, pubtype = {workshop}, url = {http://cazzola.di.unimi.it/pubs/ramse05-www.pdf}, keywords = {AOP evolution design}, abstract = {Software modeling has received a lot a of attention in the last decade and now is an important support for the design process. Actually, the design process is very important to the usability and understandability of the system, for example functional requirements present a \textit{complete} description of how the system will function from the user's perspective, while non-functional requirements dictate properties and impose constraints on the project or system. The design models and implementation code must be strictly connected, i.e. we must have correlation and consistency between the two previous views, and this correlation must exist during all the software cycle. Often, the early stages of development, the specifications and the design of the system, are ignored once the code has been developed. This practice cause a lot of problems, in particular when the system must evolve. Nowadays, to maintain a software is a difficult task, since there is a high coupling degree between the software itself and its environment. Often, changes in the environment cause changes in the software, in other words, the system must evolve itself to follow the evolution of its environment. Typically, a design is created initially, but as the code gets written and modified, the design is not updated to reflect such changes. This paper describes and discusses how the design information can be used to drive the software evolution and consequently to maintain consistency among design and code.}, note = {} } @INPROCEEDINGS{Cazzola05d, author = {Walter Cazzola and Antonio Cicchetti and Alfonso Pierantonio}, title = {{On the Problems of the JPMs}}, editor = {}, booktitle = {Proceedings of the 1st ECOOP Workshop on Models and Aspects (MAW'05)}, number = {}, series = {}, year = 2005, address = {Glasgow, Scotland}, organization = {}, publisher = {}, pages = {}, month = jul, pubtype = {workshop}, url = {http://cazzola.di.unimi.it/pubs/maw05-www.pdf}, keywords = {AOP design}, note = {} } @INPROCEEDINGS{Cazzola05e, author = {Simonov, Mikhail and Sammartino, Luca and Ancona, Massimo and Pini, Sonia and Cazzola, Walter and Frascio, Marco}, title = {{Information, Knowledge and Interoperability for Healthcare Domain}}, editor = {Nesi, Paolo and Ng, Kia and Delgado, Jaime}, booktitle = {Proceedings of the 1st International Conference on Automated Production of Cross Media Content for Multi-Channel Distribution (AXMEDIS'05)}, number = {}, series = {}, year = 2005, address = {Florence, Italy}, organization = {}, publisher = {IEEE Computer Society Press}, pages = {35-42}, month = dec, pubtype = {conference}, url = {}, keywords = {e-health}, abstract = {}, note = {} } @INPROCEEDINGS{Cazzola05g, author = {Antonio Cisternino and Walter Cazzola and Diego Colombo}, title = {{Metadata-Driven Library Design}}, editor = {}, booktitle = {Proceedings of Library-Centric Software Design Workshop (LCSD'05)}, number = {}, series = {}, year = 2005, address = {San Diego, CA, USA}, organization = {}, publisher = {}, pages = {}, month = oct, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/lcsd05-www.pdf}, keywords = {reflection meta-data programming}, abstract = {Library development has greatly benefited by the wide adoption of virtual machines like Java and Microsoft .NET. Reflection services and first class dynamic loading have contributed to this trend. Microsoft introduced the notion of custom annotation, which is a way for the programmer to define custom meta-data stored along reflection meta-data within the executable file. Recently also Java has introduced an equivalent notion into the virtual machine. Custom annotations allow the programmer to give hints to libraries about his intention without having to introduce semantics dependencies within the program; on the other hand these annotations are read at run-time introducing a certain amount of overhead. The aim of this paper is to investigate the impact of this new feature on library design, focusing both on expressivity and performance issues.}, note = {} } @ARTICLE{Cazzola05h, author = {Walter Cazzola and Antonio Cisternino and Diego Colombo}, title = {{Freely Annotating C\#}}, journal = {Journal of Object Technology}, publisher = {}, year = 2005, volume = 4, number = 10, pages = {31-48}, month = dec, ISSN = {}, pubtype = {journal}, url = {http://cazzola.di.unimi.it/pubs/jot05-www.pdf}, keywords = {reflection meta-data}, abstract = {Reflective programming is becoming popular due to the increasing set of dynamic services provided by execution environments like JVM and CLR. With custom attributes Microsoft introduced an extensible model of reflection for CLR: they can be used as additional decorations on element declarations. The same notion has been introduced in Java 1.5. The annotation model, both in Java and in C\#, limits annotations to classes and class members. In this paper we describe [a]C\#, an extension of the C\# programming language, that allows programmers to annotate statements and code blocks and retrieve these annotations at run-time. We show how this extension can be reduced to the existing model. A set of operations on annotated code blocks to retrieve annotations and manipulate bytecode is introduced. We also discuss how to use [a]C\# to annotate programs giving hints on how to parallelize a sequential method and how it can be implemented by means of the abstractions provided by the run-time of the language. Finally, we show how our model for custom attributes has been realized.}, note = {} } @BOOK{Cazzola05i, editor = {Walter Cazzola and Shigeru Chiba and Gunter Saake and Tom Tourw\'e}, title = {{Proceedings of the 2nd ECOOP Workshop on Reflection, AOP and Meta-Data for Software Evolution (RAM-SE'05)}}, year = 2005, series = {}, address = {}, month = nov, pubtype = {editor}, url = {http://cazzola.di.unimi.it/RAM-SE proceedings/RAM-SE05 Proceedings.pdf}, keywords = {reflection AOP meta-data evolution}, publisher = {Preprint No. 9/2005 of Fakult\"{a}t f\"{u}r Informatik, Otto-von-Guericke-Universit\"{a}t Magdeburg} } @INPROCEEDINGS{Cazzola06, author = {Walter Cazzola and Antonio Cicchetti and Alfonso Pierantonio}, title = {{Towards a Model-Driven Join Point Model}}, editor = {}, booktitle = {Proceedings of the 11th Annual ACM Symposium on Applied Computing (SAC'06)}, number = {}, series = {}, year = 2006, address = {Dijon, France}, organization = {}, publisher = {ACM Press}, pages = {1306-1307}, month = apr, pubtype = {conference}, url = {http://dl.acm.org/authorize?817525}, long = {http://cazzola.di.unimi.it/pubs/sac06-www-long.pdf}, keywords = {AOP design}, abstract = {Aspect--Oriented Programming (AOP) is increasingly being adopted by developers to better modularize object--oriented design by introducing crosscutting concerns. However, due to tight coupling of existing approaches with the implementing code and to the poor expressiveness of the pointcut languages a number of problems became evident. Model--Driven Architecture (MDA) is an emerging technology that aims at shifting the focus of software development from a programming language specific implementation to application design, using appropriate representations by means of models which could be transformed toward several development platforms. Therefore, this work presents a possible solution based on modeling aspects at a higher level of abstraction which are, in turn, transformed to specific targets.}, note = {} } @INPROCEEDINGS{Cazzola06b, author = {Walter Cazzola and Jean-Marc J\'ez\'equel and Awais Rashid}, title = {{Semantic Join Point Models: Motivations, Notions and Requirements}}, editor = {}, booktitle = {Proceedings of the Software Engineering Properties of Languages and Aspect Technologies Workshop (SPLAT'06)}, number = {}, series = {}, year = 2006, address = {Bonn, Germany}, organization = {}, publisher = {}, pages = {}, month = mar, pubtype = {workshop}, url = {http://cazzola.di.unimi.it/pubs/splat06-www.pdf}, keywords = {AOP}, abstract = {Aspect-oriented programming (AOP) has been designed to provide a better separation of concerns at development level by modularizing concerns that would otherwise be tangled and scattered across other concerns. Current mainstream AOP techniques separate crosscutting concerns on a syntactic basis whereas a concern is more a semantic matter. Therefore, a different, more semantic-oriented, approach to AOP is needed. In this position paper, we investigate the limitations of mainstream AOP techniques, mainly \aspectj, in this regard and highlight the issues that need to be addressed to design semantic-based join point models.}, note = {} } @INPROCEEDINGS{Cazzola06c, author = {Massimo Ancona and Walter Cazzola and Sara Drago and Gianluca Quercini}, title = {{Visualizing and Managing Network Topologies via Rectangular Dualization}}, editor = {}, booktitle = {Proceedings of the IEEE Symposium on Computers and Communications (ISCC'06)}, number = {}, series = {}, year = 2006, address = {Pula, Sardinia, Italy}, organization = {}, publisher = {}, pages = {1000-1005}, month = jun, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/iscc06-www.pdf}, keywords = {programming}, abstract = {Rectangular dualization is an effective, hierarchically oriented visualization method for network topologies and can be used in many other problems having in common with networks the condition that objects and their interoccurring relations are represented by means of a planar graph. However, only 4-connected triangulated planar graphs admit a rectangular dual. In this paper we present a linear time algorithm to optimally construct a rectangular layout for a general class of graphs and we discuss a variety of application fields where this approach represents an helpful support for visualization tools.}, note = {} } @INPROCEEDINGS{Cazzola06d, author = {Ancona, Massimo and Cappello, Marco and Casamassima, Marco and Cazzola, Walter and Conte, Davide and Pittore, Massimiliano and Quercini, Gianluca and Scagliola, Naomi and Villa, Matteo}, title = {{Mobile Vision and Cultural Heritage: the Agamemnon Project}}, booktitle = {{Proceedings of the 1st International Workshop on Mobile Vision}}, year = 2006, editor = {Schiele, Bernt and van Gool, Luc and Paletta, Lucas}, pages = {}, address = {Graz, Austria}, organization = {}, publisher = {}, volume = {}, number = {}, series = {}, month = may, pubtype = {conference}, url = {}, keywords = {}, abstract = {}, note = {} } @INPROCEEDINGS{Cazzola06e, author = {Cazzola, Walter and Ghoneim, Ahmed and Saake, Gunter}, title = {{Viewpoint for Maintaining UML Models against Application Changes}}, booktitle = {{Proceedings of International Conference on Software and Data Technologies (ICSOFT 2006)}}, year = 2006, editor = {Filipe, Joaquim and Helfert, Markus and Shishkov, Boris}, pages = {263-268}, address = {Set\'ubal, Portugal}, organization = {}, publisher = {Springer}, volume = {}, number = {}, series = {}, isbn = {978-8865-69-4}, month = sep, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/icsoft06-www.pdf}, keywords = {reflection design evolution}, abstract = {The urgency that characterizes many requests for evolution forces the system administrators/developers of directly adapting the system without passing through the adaptation of its design. This creates a gap between the design information and the system it describes. The existing design models provide a \textit{static} and often outdated snapshot of the system unrespectful of the system changes. Software developers spend a lot of time on evolving the system and then on updating the design information according to the evolution of the system. To this respect, we present an approach to automatically keep the design information (\uml diagrams in our case) updated when the system evolves. The \uml diagrams are bound to the application and all the changes to it are reflected to the diagrams as well.}, note = {} } @INPROCEEDINGS{Cazzola06f, author = {Walter Cazzola and Sonia Pini and Massimo Ancona}, title = {{Design-Based Pointcuts Robustness Against Software Evolution}}, editor = {Cazzola, Walter and Chiba, Shigeru and Coady, Yvonne and Saake, Gunter}, booktitle = {Proceedings of the 3rd ECOOP Workshop on Reflection, AOP and Meta-Data for Software Evolution (RAM-SE'06)}, number = {}, series = {}, year = 2006, address = {Nantes, France}, organization = {}, publisher = {}, pages = {35-45}, month = jul, pubtype = {workshop}, url = {http://cazzola.di.unimi.it/pubs/ramse06-www.pdf}, keywords = {AOP evolution design}, abstract = {Aspect-Oriented Programming (AOP) is a powerful technique to better modularize object-oriented programs by introducing crosscutting concerns in a safe and noninvasive way. Unfortunately, most of the current join point models are too coupled with the application code. This fact harms the evolvability of the program, hinders the concerns selection and reduces the aspect reusability. To overcome this problem is an hot topic. This work propose a possible solution to the limits of the current aspect-oriented techniques based on modeling the join point selection mechanism at a higher level of abstraction to decoupling base program and aspects. In this paper, we will present by examples a novel join point model based on design models (e.g., expressed through UML diagrams). Design models provide a high-level view on the application structure and behavior decoupled by base program. A design oriented join point model will render aspect definition more robust against base program evolution, reusable and independent of the base program.}, note = {} } @INPROCEEDINGS{Cazzola06g, author = {Cazzola, Walter and Pini, Sonia}, title = {{Join Point Patterns: a High-Level Join Point Selection Mechanism}}, booktitle = {{MoDELS'06 Satellite Events Proceedings}}, year = 2006, editor = {Kh{\"u}ne, Thomas}, pages = {17-26}, address = {Genova, Italy}, organization = {}, publisher = {Springer}, volume = {}, number = {}, series = {Lecture Notes in Computer Science 4364}, month = oct, pubtype = {inbook}, url = {http://cazzola.di.unimi.it/pubs/aom06-www.pdf}, keywords = {AOP design evolution}, abstract = {Aspect-Oriented Programming is a powerful technique to better modularize object-oriented programs by introducing crosscutting concerns in a safe and noninvasive way. Unfortunately, most of the current join point models are too coupled with the application code. This fact hinders the concerns separability and reusability since each aspect is strictly tailored on the base application. This work proposes a possible solution to this problem based on modeling the join points selection mechanism at a higher level of abstraction. In our view, the aspect designer does not need to know the inner details of the application such as a specific implementation or the used name conventions rather he exclusively needs to know the application behavior to apply his/her aspects. In the paper, we present a novel join point model with a join point selection mechanism based on a high-level program representation. This high-level view of the application decouples the aspects definition from the base program structure and syntax. The separation between aspects and base program will render the aspects more reusable and independent of the manipulated application. }, note = {Best Paper Awards at the 9th Aspect-Oriented Modeling Workshop} } @INPROCEEDINGS{Cazzola06h, author = {Kienzle, J{\"o}rg and Stein, Dominik and Cazzola, Walter and Gray, Jeff and Aldawud, Omar and Tzilla, Elrad}, title = {{9th International Workshop on Aspect-Oriented Modeling (Report)}}, booktitle = {{MoDELS'06 Satellite Events Proceedings}}, year = 2006, editor = {Kh{\"u}ne, Thomas}, pages = {1-5}, address = {Genova, Italy}, organization = {}, publisher = {Springer}, volume = {}, number = {}, series = {Lecture Notes in Computer Science 4364}, month = oct, pubtype = {report}, url = {http://cazzola.di.unimi.it/pubs/aom06-report.pdf}, keywords = {AOP design}, note = {} } @INPROCEEDINGS{Cazzola06i, author = {Ancona, Massimo and Cazzola, Walter and Pini, Sonia and Alonso, Albert and Randall, Gary and Bekiaris, Vassilis and Frascio, Marco and Lovat, Eddie and Conconi, Alex and Sammartino, Luca and Tsagalis, Kostas}, title = {{Informed Decision Making and Interoperability in Medicine: the Doc@Hand Experience}}, booktitle = {{Proceedings of the 5th International Conference on Information Technology in Biomedicine (ITAB 2006)}}, year = 2006, editor = {}, pages = {1-5}, address = {Ioannina - Epirus, Greece}, organization = {}, publisher = {IEEE Press}, volume = {}, number = {}, series = {}, month = oct , pubtype = {conference}, url = {}, keywords = {e-health}, abstract = {}, note = {} } @BOOK{Cazzola06j, editor = {Cazzola, Walter and Chiba, Shigeru and Coady, Yvonne and Saake, Gunter}, title = {{Proceedings of the 3rd ECOOP Workshop on Reflection, AOP and Meta-Data for Software Evolution (RAM-SE'06)}}, year = 2006, series = {}, address = {}, month = nov, pubtype = {editor}, url = {http://cazzola.di.unimi.it/RAM-SE proceedings/RAM-SE06 Proceedings.pdf}, keywords = {reflection AOP meta-data evolution}, publisher = {Fakult\"{a}t f\"{u}r Informatik, Otto-von-Guericke-Universit\"{a}t Magdeburg} } @INCOLLECTION{Cazzola06k, author = {Cazzola, Walter and Chiba, Shigeru and Coady, Yvonne and Saake, Gunter}, title = {{AOSD and Reflection: Benefits and Drawbacks to Software Evolution}}, editor = {Consel, Charles and S{\"u}dholt, Mario}, booktitle = {{ECOOP'06 Workshop Reader}}, series = {Lecture Notes in Computer Science 4379}, publisher = {Springer-Verlag}, address = {}, edition = {}, month = jul, year = 2006, pubtype = {report}, url = {http://cazzola.di.unimi.it/pubs/ramse06-report.pdf}, keywords = {reflection AOP meta-data evolution}, pages = {40-52} } @ARTICLE{Cazzola06l, author = {Lorenzo Capra and Walter Cazzola}, title = {{A Petri-Net Based Reflective Framework for the Evolution of Dynamic Systems}}, editor = {Arbab, Farhad and Sirjani, Marjan}, journal = {{Electronic Notes on Theoretical Computer Science}}, year = 2006, volume = 159, number = {}, pages = {41-59}, month = {}, pubtype = {journal}, url = {http://cazzola.di.unimi.it/pubs/fsen05-etncs-www.pdf}, keywords = {reflection evolution petri-net}, abstract = {Nowadays, software evolution is a very hot topic. Many applications need to be updated or extended with new characteristics during their lifecycle. Software evolution is characterized by its huge cost and slow speed of implementation. Often, software evolution implies a redesign of the whole system, the development of new features and their integration in the existing and/or running systems (this last step often implies a complete rebuilding of the system). A good evolution is carried out through the evolution of the system design information and then propagating the evolution to the implementation. Petri Nets (PN), as a formalism for modeling and designing distributed/concurrent software systems, are not exempt from this issue. Several times a system modeled through Petri nets has to be updated and consequently also the model should be updated. Often, some kinds of evolution are foreseeable and could be hardcoded in the code or in the model, respectively. Embedding evolutionary steps in the model or in the code however requires early and full knowledge of the evolution. The model itself should be augmented with details that do not regard the current system functionality, and that jeopardize or make very hard analysis and verification of system properties. In this work, we propose a PN based reflective framework that lets everyone model a system able to evolve, keeping separated functional aspects from evolutionary ones and applying evolution to the model if necessary. Such an approach tries to keep the model as simple as possible, preserving (and exploiting) the ability of formally verifying system properties typical of PN, granting at the same time model adaptability.}, note = {} } @INPROCEEDINGS{Cazzola06m, author = {Villa, Matteo and Ancona, Massimo and Cazzola, Walter}, title = {{Agamemnon: A Multimedia Guide to Archaeological Sites on Mobile Phones}}, booktitle = {{Proceedings of eChallenges (e2006)}}, year = 2006, editor = {Cunningham, Paul and Cunningham, Miriam}, pages = {1760-1768}, address = {Barcelona, Spain}, organization = {}, publisher = {IOS Press}, volume = {}, number = {}, series = {}, month = oct, isbn = {1-58603-682-3}, pubtype = {conference}, url = {}, keywords = {}, abstract = {}, note = {} } @INPROCEEDINGS{Cazzola07, author = {Cazzola, Walter and Pini, Sonia and Ghoneim, Ahmed and Saake, Gunter}, title = {{Co-Evolving Application Code and Design Models by Exploiting Meta-Data}}, editor = {}, booktitle = {Proceedings of the 12th Annual ACM Symposium on Applied Computing (SAC'07)}, number = {}, series = {}, year = 2007, address = {Seoul, South Korea}, organization = {}, publisher = {ACM Press}, pages = {1275-1279}, month = mar, pubtype = {conference}, url = {http://dl.acm.org/authorize?978656}, keywords = {evolution meta-data reflection design}, abstract = {Evolvability and adaptability are intrinsic properties of today's software applications. Unfortunately, the urgency of evolving/adapting a system often drives the developer to directly modify the application code neglecting to update its design models. Even, most of the development environments support the code refactoring without supporting the refactoring of the design information. Refactoring, evolution and in general every change to the code should be reflected into the design models, so that these models consistently represent the application and can be used as documentation in the successive maintenance steps. \textit{The code evolution should not evolve only the application code but also its design models.} Unfortunately, to co-evolve the application code and its design is a hard job to be carried out automatically, since there is an evident and notorious \textit{gap} between these two representations. We propose a new approach to code evolution (in particular to code refactoring) that supports the automatic co-evolution of the design models. The approach relies on a set of predefined meta-data that the developer should use to annotate the application code and to highlight the refactoring performed on the code. Then, these meta-data are retrieved through reflection and used to automatically and coherently update the application design models.}, note = {} } @TECHREPORT{Cazzola07b, author = {Walter Cazzola and Alessandro Marchetto}, title = {{\hiddenmetrics}}, institution = {{Universit\`a degli Studi di Milano}}, year = 2007, type = {{Technical Report}}, number = {TR 19-07}, address = {Milano, Italy}, month = jun, pubtype = {techrep}, url = {}, keywords = {AOP metrics sw-engineering}, abstract = {}, note = {} } @INPROCEEDINGS{Cazzola07c, author = {Walter Cazzola and Sonia Pini}, title = {{AOP vs Software Evolution: a Score in Favor of the Blueprint}}, editor = {Cazzola, Walter and Chiba, Shigeru and Coady, Yvonne and Ducasse, St\'ephane and Kniesel, G\"unter and Oriol, Manuel and Saake, Gunter}, booktitle = {Proceedings of the 4th ECOOP Workshop on Reflection, AOP and Meta-Data for Software Evolution (RAM-SE'07)}, number = {}, series = {}, year = 2007, address = {Berlin, Germany}, organization = {}, publisher = {}, pages = {81-91}, month = jul, pubtype = {workshop}, url = {http://cazzola.di.unimi.it/pubs/ramse07-www.pdf}, keywords = {AOP evolution design}, abstract = {All software systems are subject to evolution, independently by the developing technique. Aspect oriented software in addition to separate the different concerns during the software development, must be ``not \textit{fragile}'' against software evolution. Otherwise, the benefit of disentangling the code will be burred by the extra complication in maintaining the code. To obtain this goal, the aspect-oriented languages/tools must evolve, they have to be less coupled to the base program. In the last years, a few attempts have been proposed, the Blueprint is our proposal based on behavioral patterns. In this paper we test the robustness of the Blueprint aspect-oriented language against software evolution.}, note = {} } @ARTICLE{Cazzola07d, author = {Cazzola, Walter and Pini, Sonia}, title = {{On the Footprints of Join Points: The Blueprint Approach}}, journal = {{Journal of Object Technology}}, year = 2007, volume = 6, number = 7, pages = {167-192}, month = aug, pubtype = {journal}, url = {http://cazzola.di.unimi.it/pubs/jot07-www.pdf}, keywords = {AOP evolution design}, abstract = {Aspect-oriented techniques are widely used to better modularize object-oriented programs by introducing crosscutting concerns in a safe and non-invasive way, i.e., aspect-oriented mechanisms better address the modularization of functionality that orthogonally crosscuts the implementation of the application. Unfortunately, as noted by several researchers, most of the current aspect-oriented approaches are too coupled with the application code, and this fact hinders the concerns separability and consequently their re-usability since each aspect is strictly tailored on the base application. Moreover, the join points (i.e., locations affected by a crosscutting concerns) actually are defined at the \textit{operation level}. It implies that the possible set of join points includes every operation (e.g., method invocations) that the system performs. Whereas, in many contexts we wish to define aspects that are expected to work at the \textit{statement level}, i.e., by considering as a join point every point between two generic statements (i.e., lines of code). In this paper, we present our approach, called Blueprint, to overcome the abovementioned limitations of the current aspect-oriented approaches. The \blueprint consists of a new aspect-oriented programming language based on modeling the join point selection mechanism at a high-level of abstraction to decouple aspects from the application code. To this regard, we adopt a high-level pattern-based join point model, where join points are described by \textit{join point blueprints}, i.e., behavioral patterns describing where the join points should be found.}, note = {} } @ARTICLE{Cazzola07e, author = {Lorenzo Capra and Walter Cazzola}, title = {{Self-Evolving Petri Nets}}, journal = {{Journal of Universal Computer Science}}, year = 2007, volume = 13, number = 13, pages = {2002-2034}, month = dec, pubtype = {journal}, url = {http://cazzola.di.unimi.it/pubs/jucs07-www.pdf}, keywords = {petri-net evolution reflection}, abstract = {Nowadays, software evolution is a very hot topic. It is particularly complex when it regards critical and nonstopping systems. Usually, these situations are tackled by hard-coding all the foreseeable evolutions in the application design and code. Neglecting the obvious difficulties in pursuing this approach, we also get the application code and design polluted with details that do not regard the current system functionality, and that hamper design analysis, code reuse and application maintenance in general. Petri Nets (PN), as a formalism for modeling and designing distributed/concurrent software systems, are not exempt from this issue. The goal of this work is to propose a PN based reflective framework that lets everyone model a system able to evolve, keeping separated functional aspects from evolutionary ones and applying evolution to the model only if necessary. Such an approach tries to keep system's model as simple as possible, preserving (and exploiting) ability of formally verifying system properties typical of PN, granting at the same time adaptability.}, note = {} } @INPROCEEDINGS{Cazzola07f, author = {Capra, Lorenzo and Cazzola, Walter}, title = {{A Reflective PN-based Approach to Dynamic Workflow Change}}, booktitle = {{Proceedings of the 9th International Symposium in Symbolic and Numeric Algorithms for Scientific Computing (SYNASC'07)}}, year = 2007, editor = {}, pages = {533-540}, address = {Timi\c{s}oara, Romania}, organization = {IEEE}, publisher = {}, volume = {}, number = {}, series = {}, month = sep, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/synasc07-www.pdf}, keywords = {petri-net evolution reflection}, abstract = {The design of dynamic workflows needs adequate modeling/specification formalisms and tools to soundly handle possible changes occurring during workflow operation. A common approach is to pollute design with details that do not regard the current workflow behavior, but rather its evolution. That hampers analysis, reuse and maintenance in general. We propose and discuss the adoption of a recent Petri Net based reflective model (based on classical PN) as a support to dynamic workflow design, by addressing a localized problem: how to determine what tasks should be redone and which ones do not when transferring a workflow instance from an old to a new template. Behind there is the idea that keeping functional aspects separated from evolutionary ones, and applying evolution to the (current) workflow template only when necessary, results in a simple reference model on which the ability of formally verifying typical workflow properties is preserved, thus favoring a dependable adaptability.}, note = {} } @ARTICLE{Cazzola07g, author = {Cazzola, Walter and Gray, Jeff and Stein, Dominik and Kienzle, J\"org and Elrad, Tzilla and Aldawud (Eds), Omar}, title = {{Special Issue on Aspect-Oriented Modeling}}, journal = {{Journal of Object Technology}}, year = 2007, volume = 6, number = 7, publisher = {ETH Zürich, Chair of SW Engineering}, pages = {}, month = aug, pubtype = {editor}, url = {http://www.jot.fm/issues/issue_2007_08/}, keywords = {AOP design}, note = {} } @ARTICLE{Cazzola07h, author = {Cazzola, Walter and Chiba, Shigeru and Saake (Eds), Gunter}, title = {{Special Issue on Software Evolution}}, journal = {{Transaction on Aspect-Oriented SW Development}}, year = 2007, volume = 1, number = 4, publisher = {Springer}, pages = {}, month = oct, pubtype = {editor}, keywords = {AOP evolution}, note = {Printed on Lecture Notes on Computer Science 4640} } @BOOK{Cazzola07i, editor = {Cazzola, Walter and Chiba, Shigeru and Coady, Yvonne and Ducasse, St\'ephane and Kniesel, G\"unter and Oriol, Manuel and Saake, Gunter}, title = {{Proceedings of the 4th ECOOP Workshop on Reflection, AOP and Meta-Data for Software Evolution (RAM-SE'07)}}, year = 2007, series = {}, address = {}, month = nov, pubtype = {editor}, url = {http://cazzola.di.unimi.it/RAM-SE proceedings/RAM-SE07 Proceedings.pdf}, keywords = {reflection AOP meta-data evolution}, publisher = {Fakult\"{a}t f\"{u}r Informatik, Otto-von-Guericke-Universit\"{a}t Magdeburg} } @INPROCEEDINGS{Cazzola07j, author = {Kienzle, J{\"o}rg and Gray, Jeff and Stein, Dominik and Cazzola, Walter and Aldawud, Omar and Tzilla, Elrad}, title = {{11th International Workshop on Aspect-Oriented Modeling (Report)}}, booktitle = {{MoDELS 2007 Workshops}}, year = 2007, editor = {Giese, Holger}, pages = {1-6}, address = {Nashville, TN, USA}, organization = {}, publisher = {Springer}, volume = {}, number = {}, series = {Lecture Notes in Computer Science 5002}, month = sep, pubtype = {report}, url = {http://cazzola.di.unimi.it/pubs/aom07-report.pdf}, keywords = {AOP design}, note = {} } @INPROCEEDINGS{Cazzola08, author = {Capra, Lorenzo and Cazzola, Walter}, title = {{Evolutionary Design through Reflective Petri Nets: an Application to Workflow}}, booktitle = {{Proceedings of the 26th IASTED International Conference on Software Engineering (SE'08)}}, year = 2008, editor = {}, pages = {200-207}, address = {Innsbruck, Austria}, organization = {}, publisher = {ACTA Press}, volume = {}, number = {}, series = {}, isbn = {978-0-88986-715-4}, month = feb, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/se08-www.pdf}, keywords = {petri-net evolution reflection}, abstract = {The design of dynamic workflows needs adequate modeling/specification formalisms and tools to soundly handle possible changes during workflow operation. A common approach is to pollute workflow design with details that do not regard the current behavior, but rather evolution. That hampers analysis, reuse and maintenance in general. We propose and discuss the adoption of a recent Petri net-based reflective model as a support to dynamic workflow design. Keeping separated functional aspects from evolution, results in a dynamic workflow model merging flexibility and ability of formally verifying basic workflow properties. A structural on-the-fly characterization of sound dynamic workflows is adopted based on Petri net's free-choiceness preservation. An application is presented to a localized open problem: how to determine what tasks should be redone and which ones do not when transferring a workflow instance from an old to a new template.}, note = {} } @INCOLLECTION{Cazzola08b, author = {Oriol, Manuel and Cazzola, Walter and Chiba, Shigeru and Saake, Gunter and Coady, Yvonne and Ducasse, St\'ephane and Kniesel, G\"unter}, title = {{Enabling Software Evolution via AOP and Reflection}}, editor = {Cebulla, Michael}, booktitle = {{ECOOP'07 Workshop Reader}}, series = {Lecture Notes in Computer Science 4906}, publisher = {Springer-Verlag}, address = {}, edition = {}, month = feb, year = 2008, pubtype = {report}, url = {http://cazzola.di.unimi.it/pubs/ramse07-report.pdf}, keywords = {reflection AOP evolution meta-data}, pages = {91-98} } @INPROCEEDINGS{Cazzola08c, author = {Figueiredo, Eduardo and Sant'Anna, Cl\'audio and Garcia, Alessandro and Bartolomei, Thiago T. and Cazzola, Walter and Marchetto, Alessandro}, title = {{On the Maintainability of Aspect-Oriented Software: A Concern-Oriented Measurement Framework}}, booktitle = {{Proceedings of the 12th European Conference on Software Maintenance and Reengineering (CSMR 2008)}}, year = 2008, editor = {Tjortjis, Christos and Winter, Andreas}, pages = {183-192}, address = {Athens, Greece}, organization = {}, publisher = {IEEE Press}, volume = {}, number = {}, series = {}, month = apr, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/csmr08-www.pdf}, keywords = {metrics AOP sw-engineering}, abstract = {Aspect-oriented design needs to be systematically assessed with respect to modularity flaws caused by the realization of driving system concerns, such as tangling, scattering, and excessive concern dependencies. As a result, innovative concern metrics have been defined to support quantitative analyses of concern's properties. However, the vast majority of these measures have not yet being theoretically validated and managed to get accepted in the academic or industrial settings. The core reason for this problem is the fact that they have not been built by using a clearly-defined terminology and criteria. This paper defines a concern-oriented framework that supports the instantiation and comparison of concern measures. The framework subsumes the definition of a core terminology and criteria in order to lay down a rigorous process to foster the definition of meaningful and well-founded concern measures. In order to evaluate the framework generality, we demonstrate the framework instantiation and extension to a number of concern measures suites previously used in empirical studies of aspect-oriented software maintenance.}, note = {} } @ARTICLE{Cazzola08d, author = {Cazzola, Walter and Marchetto, Alessandro}, title = {{\hiddenmetrics: Separation, Extensibility and Adaptability in SW Measurement}}, journal = {{Journal of Object Technology}}, year = 2008, volume = 7, number = 2, pages = {53-68}, month = feb, pubtype = {journal}, url = {http://cazzola.di.unimi.it/pubs/jot08-www.pdf}, keywords = {metrics AOP sw-engineering}, abstract = {Traditional approaches to dynamic system analysis and metrics measurement are based on system code (both source, intermediate and executable code) instrumentation or need \textit{ad hoc} support by the run-time environment. In these contexts, the measurement process is tricky, invasive and the results could be affected by the process itself making the data not germane. Moreover, the tool based on these approaches are difficult to customize, extend and often use since their properties are rooted at specific system details (e.g., special tools such as bytecode analyzers or virtual machine goodies such as the debugger interface) and require high efforts, skills and knowledges to be adapted. Notwithstanding its importance, software measurement is clearly a nonfunctional concern and should not impact on the software development and efficiency. Aspect-oriented programming provides the mechanisms to deal with this kind of concern and to overcome the software measurement limitations. In this paper, we present a different approach to dynamic software measurements based on aspect-oriented programming and the corresponding support framework named \hiddenmetrics. The proposed approach makes the measurement process highly customizable and easy to use reducing its invasiveness and the dependency from the code knowledge.}, note = {} } @TECHREPORT{Cazzola08f, author = {Cazzola, Walter and Pini, Sonia}, title = {{Jigsaw: Information System Composition through a Self-Adaptable Interface}}, institution = {{Department of Informatics and Communication, University of Milan}}, year = 2008, type = {Technical Report}, number = {RT 26-08}, address = {Milan, Italy}, month = apr, pubtype = {techrep}, url = {}, keywords = {reflection evolution}, abstract = {}, note = {} } @BOOK{Cazzola08g, editor = {Cazzola, Walter and Chiba, Shigeru and Oriol, Manuel and Saake, Gunter}, title = {{Proceedings of the 5th ECOOP Workshop on Reflection, AOP and Meta-Data for Software Evolution (RAM-SE'08)}}, year = 2008, series = {}, address = {}, month = dec, publisher = {Fakultät für Informatik, Otto-von-Guericke-Universität Magdeburg}, pubtype = {editor}, url = {http://cazzola.di.unimi.it/RAM-SE proceedings/RAM-SE08 Proceedings.pdf}, keywords = {reflection evolution AOP meta-data}, note = {} } @INPROCEEDINGS{Cazzola09, author = {Cazzola, Walter and Colombo, Diego and Harrison, Duncan}, title = {{Aspect-Oriented Procedural Content Engineering for Game Design}}, booktitle = {{Proceedings of the 14th Annual ACM Symposium on Applied Computing (SAC'09)}}, year = 2009, editor = {}, pages = {1957-1962}, address = {Honolulu, Hawai'i, USA}, organization = {ACM}, publisher = {}, volume = {}, number = {}, series = {}, month = mar, pubtype = {conference}, url = {http://dl.acm.org/authorize?178238}, keywords = {AOP meta-data}, abstract = {Generally progressive \textit{procedural content} in the context of 3D scene rendering is expressed as recursive functions where a finer \textit{level of detail} gets computed on demand. Typical examples of content procedurally generated are fractal images and noise textures. Unfortunately, not always the content can be expressed in this way, developers and content creators need the data to have some peculiarity (like windows on a wall for a house 3D model) and a method to drive data simplification without losing relevant details. In this paper we discuss how \textit{aspect oriented} (AO) techniques can be used to drive the content creation process by mapping each data peculiarity to the code to generate it. Using \textit{aspects} will let us to partially evaluate the code of the procedure improving the performance without losing the flow of the generation logic. We will also discuss how the use of AO can provide techniques to build simplified version of the data through code transformations.}, note = {} } @INCOLLECTION{Cazzola09b, author = {Capra, Lorenzo and Cazzola, Walter}, editor = {Abu-Taieh, Evon M. O. and El Sheikh, Asim A.}, title = {{An Introduction to Reflective Petri Nets}}, booktitle = {{Handbook of Research on Discrete Event Simulation Environments: Technologies and Applications}}, publisher = {IGI Global}, year = 2009, chapter = 9, pages = {191-217}, address = {}, volume = {}, number = {}, series = {}, type = {}, edition = {}, month = nov, isbn = {978-1-60566-774-4}, pubtype = {inbook}, url = {http://cazzola.di.unimi.it/pubs/RPN09-chap09-www.pdf}, keywords = {reflection evolution petri-net}, abstract = {Most discrete-event systems are subject to evolution during lifecycle. Evolution often implies the development of new features, and their integration in deployed systems. Taking evolution into account since the design phase therefore is mandatory. A common approach consists of hard-coding the foreseeable evolutions at the design level. Neglecting the obvious ifficulties of this approach, we also get system's design polluted by details not concerning functionality, which hamper analysis, reuse and maintenance. Petri Nets, as a central formalism for discrete-event systems, are not exempt from pollution when facing evolution. Embedding evolution in Petri nets requires expertise, other than early knowledge of evolution. The complexity of resulting models is likely to affect the consolidated analysis algorithms for Petri nets. We introduce Reflective Petri nets, a formalism for dynamic discrete-event systems. Based on a reflective layout, in which functional aspects are separated from evolution, this model preserves the description effectiveness and the analysis capabilities of Petri nets. Reflective Petri nets are provided with timed state-transition semantics.}, note = {} } @INCOLLECTION{Cazzola09c, author = {Capra, Lorenzo and Cazzola, Walter}, editor = {Abu-Taieh, Evon M. O. and El Sheikh, Asim A.}, title = {{Trying out Reflective Petri Nets on a Dynamic Workflow Case}}, booktitle = {{Handbook of Research on Discrete Event Simulation Environments: Technologies and Applications}}, publisher = {IGI Global}, year = 2009, chapter = 10, pages = {218-233}, address = {}, volume = {}, number = {}, series = {}, type = {}, edition = {}, month = nov, isbn = {978-1-60566-774-4}, pubtype = {inbook}, url = {http://cazzola.di.unimi.it/pubs/RPN09-chap10-www.pdf}, keywords = {reflection evolution petri-net}, abstract = {Industrial/business processes are an evident example of discrete-event systems which are subject to evolution during life-cycle. The design and management of dynamic workflows need adequate formal models and support tools to handle in sound way possible changes occurring during workflow operation. The known, well-established workflow's models, among which Petri nets play a central role, are lacking in features for representing evolution. We propose a recent Petri net-based reflective layout, called Reflective Petri nets, as a formal model for dynamic workflows. A localized open problem is considered: how to determine what tasks should be redone and which ones do not when transferring a workflow instance from an old to a new template. The problem is efficiently but rather empirically addressed in a workflow management system. Our approach is formal, may be generalized, and is based on the preservation of classical Petri nets structural properties, which permit an efficient characterization of workflow's soundness.}, note = {} } @INPROCEEDINGS{Cazzola09d, author = {Walter Cazzola and Stefano Salvotelli}, title = {{Recognizing Join Points from their Context through Graph Grammars}}, booktitle = {{Proceedings of the 13th Aspect-Oriented Modeling Workshop (AOM'09)}}, year = 2009, editor = {}, pages = {37-42}, address = {Charlottesville, Virginia, USA}, organization = {}, publisher = {ACM}, volume = {}, number = {}, series = {}, month = mar, pubtype = {workshop}, url = {http://dl.acm.org/authorize?010685}, keywords = {AOP}, abstract = {Aspect-oriented software development has been proposed with the intent of better modularizing object-oriented programs by confining crosscutting concerns in aspects. Unfortunately, the aspects do not completely keep their promises. Most of the current approaches revealed to be tightly coupled with the base-program's code compromising the modularity. Moreover, the feasible modularization has a coarse-grain since the aspects can only be woven at the public interface level but not on a generic statement. We have designed the Blueprint framework to overcome these limits. The join points are located through the description of the context where they could be found. This work is about the framework realization and the role that graph grammars play in locating the join points in the base-program from the context description.}, note = {} } @INPROCEEDINGS{Cazzola09e, author = {Walter Cazzola and Ivan Speziale}, title = {{Sectional Domain Specific Languages}}, booktitle = {{Proceedings of the 4th Domain Specific Aspect-Oriented Languages (DSAL'09)}}, year = 2009, editor = {}, pages = {11-14}, address = {Charlottesville, Virginia, USA}, organization = {}, publisher = {ACM}, volume = {}, number = {}, series = {}, month = mar, pubtype = {workshop}, url = {http://dl.acm.org/authorize?155226}, keywords = {AOP dsl modularity}, abstract = {Nowadays, many problems are solved by using a domain specific language (DSL), i.e., a programming language tailored to work on a particular application domain. Normally, a new DSL is designed and implemented from scratch requiring a long time-to-market due to implementation and testing issues. Whereas when the DSL simply extends another language it is realized as a source-to-source transformation or as an external library with limited flexibility. The Hive framework is developed with the intent of overcoming these issues by providing a mechanism to compose different programming features together forming a new DSL, what we call a \textit{sectional} DSL. The support (both at compiler and interpreter level) of each feature is separately described and easily composed with the others. This approach is quite flexible and permits to build up a new DSL from scratch or simplifying an existing language without penalties. Moreover, it has the desirable side-effect that each DSL can be extended at any time potentially also at run-time.}, note = {} } @INPROCEEDINGS{Cazzola09f, author = {Capra, Lorenzo and Cazzola, Walter}, title = {{Evolving System's Modeling and Simulation through Reflective Petri Nets}}, booktitle = {{Proceedings of the 4th International Conference on Evaluation of Novel Approaches to Software Engineering (ENASE'09)}}, year = 2009, editor = {Jablonski, Stefan and Maciaszek, Leszek}, pages = {59-70}, address = {Milan, Italy}, organization = {INSTICC}, publisher = {INSTICC Press}, volume = {}, number = {}, series = {}, month = may, isbn = {978-989-8111-98-2}, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/enase09-www.pdf}, keywords = {petri-net reflection evolution}, abstract = {The design of dynamic discrete-event systems calls for adequate modeling formalisms and tools to manage possible changes occurring during system's lifecycle. A common approach is to pollute design with details that do not regard the current system behavior rather its evolution. That hampers analysis, reuse and maintenance in general. A reflective Petri net model (based on classical Petri nets) was recently proposed to support dynamic discrete-event system's design, and was applied to dynamic workflow's management. Behind there is the idea that keeping functional aspects separated from evolutionary ones and applying them to the (current) system only when necessary, results in a simple formal model on which the ability of verifying properties typical of Petri nets is preserved. In this paper we provide the reflective Petri nets with a (labeled) state-transition graph semantics.}, note = {} } @INCOLLECTION{Cazzola09g, author = {Oriol, Manuel and Cazzola, Walter and Chiba, Shigeru and Saake, Gunter}, title = {{Getting Farther on Software Evolution via AOP and Reflection}}, editor = {Eugster, Patrick}, booktitle = {{ECOOP'08 Workshop Reader}}, series = {Lecture Notes in Computer Science 5475}, publisher = {Springer-Verlag}, address = {}, edition = {}, month = mar, year = 2009, pages = {63-69}, pubtype = {report}, url = {http://cazzola.di.unimi.it/pubs/ramse08-report.pdf}, keywords = {AOP reflection evolution}, note = {} } @INPROCEEDINGS{Cazzola09h, author = {Pukall, Mario and Siegmund, Norbert and Cazzola, Walter}, title = {{Feature-Oriented Runtime Adaptation}}, booktitle = {{Proceedings of ESEC/FSE Workshop on Software INTegration and Evolution @ Runtime (SINTER'09)}}, year = 2009, editor = {}, pages = {33-36}, address = {Amsterdam, The Netherlands}, organization = {}, publisher = {ACM}, volume = {}, number = {}, series = {}, month = aug, isbn = {978-1-60558-681-6}, pubtype = {workshop}, url = {http://dl.acm.org/authorize?128028}, keywords = {evolution}, abstract = {Creating tailor-made programs based on the concept of software product lines (SPLs) gains more and more momentum. This is, because SPLs significantly decrease development costs and time to market while increasing product's quality. Especially highly available programs benefit from the quality improvements caused by an SPL. However, after a program variant is created from an SPL and then started, the program is completely decoupled from its SPL. Changes within the SPL, i.e., source code of its features do not affect the running program. To apply the changes, the program has to be stopped, recreated, and restarted. This causes at least short time periods of program unavailability which is not acceptable for highly available programs. Therefore, we present a novel approach based on class replacements and Java HotSwap that allows to apply features to running programs.}, note = {} } @INPROCEEDINGS{Cazzola09i, author = {Cazzola, Walter}, title = {{Cogito, Ergo Muto!}}, booktitle = {{Proceedings of the Workshop on Self-Organizing Architecture (SOAR'09)}}, year = 2009, editor = {Weyns, Danny and Malek, Sam and de Lemos, Rog\'erio and Andersson, Jesper}, pages = {1-7}, address = {Cambridge, United Kingdom}, organization = {}, publisher = {}, volume = {}, number = {}, series = {}, month = sep, pubtype = {workshop}, url = {http://cazzola.di.unimi.it/pubs/soar09-www.pdf}, keywords = {evolution reflection design sw-architecture sw-engineering}, abstract = {No system escapes from the need of evolving either to fix bugs, to be reconfigured or to add new features. To evolve becomes particularly problematic when the system to evolve can not be stopped. Traditionally the evolution of a continuously running system is tackled on by calculating all the possible evolutions in advance and hardwiring them in the application itself. This approach gives origin to the code pollution phenomenon where the code of the application is polluted by code that could never be applied. The approach has the following defects: i) code bloating, ii) it is impossible to forecast any possible change and iii) the code becomes hard to read and maintain. Computational reflection by definition allows an application to introspect and intercede on its own structure and behavior endowing, therefore, a reflective application with (potent ially) the ability of self-evolving. Furthermore, to deal with the evolution as a nonfunctional concerns, i.e., that can be separated from the current implementation of the applicat ion, can limit the code pollution phenomenon. To bring the design information (model and/or architecture) at run-time provides the application with a basic knowledge about itself to reflect on when a change is necessary and on how to deploy it. The availability of such a knowledge at run-time frees the designer from forecasting and coding all the possible evolutions in favor of a sort of evolutionary engi ne that, to some extent, can evaluate which countermove to apply. In this contribution, the author will explore the role of reflection and of the design information in the development of self-evolving applications. Moreover, the author will sketch a basic reflective architecture to support dynamic self-evolution and he will analyze the adherence of the existing frameworks to such an architecture.}, note = {Invited Paper} } @TECHREPORT{Cazzola09j, author = {Pukall, Mario and K{\"a}stner, Christian and G{\"o}tz, Sebastian and Cazzola, Walter and Saake, Gunter}, title = {{Flexible Runtime Program Adaptations in Java -- A Comparison}}, institution = {Fakult{\"a}t f{\"u}r Informatik, Universit{\"a}t Magdeburg}, year = 2009, type = {Technical Report}, number = 14, address = {Magdeburg, Germany}, pubtype = {techrep}, url = {}, keywords = {evolution sw-engineering}, abstract = {}, month = nov, note = {} } @INPROCEEDINGS{Cazzola10, author = {Kienzle, J\"org and Gray, Jeff and Stein, Dominik and Cottenier, Thomas and Cazzola, Walter and Aldawud, Omar}, title = {{Report of the 14th International Workshop on Aspect-Oriented Modeling}}, booktitle = {MODELS 2009 Workshops}, year = 2010, editor = {Ghosh, Sudipto}, pages = {98--103}, address = {Denver, Colorado, USA}, organization = {}, publisher = {Springer}, volume = {Lecture Notes in Computer Science 6002}, number = {}, series = {}, pubtype = {report}, url = {http://cazzola.di.unimi.it/pubs/aom10-report.pdf}, keywords = {AOP design}, month = feb, note = {} } @INPROCEEDINGS{Cazzola10b, author = {Cazzola, Walter and Poletti, Davide}, title = {{DSL Evolution through Composition}}, booktitle = {{Proceedings of the 7th ECOOP Workshop on Reflection, AOP and Meta-Data for Software Evolution (RAM-SE'10)}}, year = 2010, editor = {}, pages = {}, address = {Maribor, Slovenia}, organization = {}, publisher = {ACM}, volume = {}, number = {}, series = {}, month = jun, pubtype = {workshop}, url = {http://dl.acm.org/authorize?79257}, keywords = {AOP dsl modularity}, abstract = {The use of domain specific languages (DSL), instead of general purpose languages introduces a number of advantages in software development even if could be problematic to maintain the DSL consistent with the evolution of the domain. Traditionally, to develop a compiler/interpreter from scratch but also to modify an existing compiler to support the novel DSL is a long and difficult task. We have developed Neverlang to simplify and speed up the development and maintenance of DSLs. The framework presented in this article not only allows to develop the syntax and the semantic of a new language from scratch but it is particularly focused on the reusability of the language definition. The interpreters/compilers produced with such a framework are modular and it is easy to add remove or modify their sections. This allows to modify the DSL definition in order to follow the evolution of the underneath domain. In this work, we explore the Neverlang framework and try out the adaptability of its language definition.}, note = {} } @INPROCEEDINGS{Cazzola10c, author = {Capra, Lorenzo and Cazzola, Walter}, title = {{(Symbolic) State-Space Inspection of a Class of Dynamic Petri Nets}}, booktitle = {{Proceedings of the Summer Computer Simulation Conference (SCSC'10)}}, year = 2010, editor = {}, pages = {522-530}, address = {Ottawa, Canada}, organization = {}, publisher = {ACM}, volume = {}, number = {}, series = {}, month = jul, pubtype = {conference}, url = {}, keywords = {reflection petri-net}, abstract = {}, note = {} } @INPROCEEDINGS{Cazzola11, author = {Pukall, Mario and Grebhahn, Alexander and Schr{\"o}ter, Reimar and K{\"a}stner, Christian and Cazzola, Walter and G{\"o}tz, Sebastian}, title = {{JavAdaptor: Unrestricted Dynamic Software Updates for Java}}, booktitle = {Proceedings of the 33rd International Conference on Software Engineering (ICSE'11)}, year = 2011, editor = {}, pages = {989-991}, address = {Waikiki, Honolulu, Hawaii}, organization = {}, publisher = {IEEE}, volume = {}, number = {}, series = {}, month = may, pubtype = {conference}, url = {http://dl.acm.org/authorize?414157}, keywords = {evolution sw-engineering}, abstract = {Dynamic software updates (DSU) are one of the top-most features requested by developers and users. As a result, DSU is already standard in many dynamic programming languages. But, it is not standard in statically typed languages such as Java. Even if at place number three of Oracle's current request for enhancement (RFE) list, DSU support in Java is very limited. Therefore, over the years many different DSU approaches for Java have been proposed. Nevertheless, DSU for Java is still an active field of research, because most of the existing approaches are too restrictive. Some of the approaches have shortcomings either in terms of flexibility or performance, whereas others are platform dependent or dictate the program's architecture. With \emph{JavAdaptor}, we present the first DSU approach which comes without those restrictions. We will demonstrate JavAdaptor based on the well-known arcade game \emph{Snake} which we will update stepwise at runtime.}, note = {} } @INPROCEEDINGS{Cazzola11b, author = {Gray, Jeff and Stein, Dominik and Kienzle, J{\"o}rg and Cazzola, Walter}, title = {{Report of the 15th International Workshop on Aspect-Oriented Modeling}}, booktitle = {{MoDELS 2010 Workshops}}, year = 2011, editor = {}, pages = {105-109}, address = {Oslo, Norway}, organization = {}, publisher = {Springer}, volume = {}, number = {}, series = {Lecture Notes in Computer Science 6627}, month = feb, pubtype = {report}, url = {}, keywords = {AOP design}, note = {} } @INCOLLECTION{Cazzola11c, author = {Ancona, Massimo and Cazzola, Walter and Pini, Sonia and Frascio, Marco}, editor = {Gasmelseid, Tajelsir Mohamed}, title = {{The Health Care Factory}}, booktitle = {{Handbook of Research on Pharmacoinformatics}}, chapter = 12, pages = {202-219}, publisher = {IGI Global}, year = 2012, address = {}, volume = {}, number = {}, series = {}, type = {}, edition = {}, month = mar, doi = {10.4018/978-1-4666-0309-7.ch012}, isbn13 = {9781466603097}, isbn10 = {1466603097}, isbn = {9781466603097}, pubtype = {inbook}, url = {}, keywords = {e-health}, abstract = {}, isbn = {978146660309}, note = {} } @INPROCEEDINGS{Cazzola12, author = {Liu, Ying and Cazzola, Walter and Zhang, Bin}, title = {{Towards a Colored Reflective Petri-Net Approach to Model Self-Evolving Service-Oriented Architectures}}, booktitle = {{Proceedings of the 17th Annual ACM Symposium on Applied Computing (SAC'12)}}, year = 2012, editor = {}, pages = {1858-1865}, address = {Riva del Garda, Trento, Italy}, organization = {}, publisher = {ACM}, volume = {}, number = {}, series = {}, month = mar, pubtype = {conference}, url = {http://dl.acm.org/authorize?6779630}, keywords = {reflection petri-net evolution}, abstract = {Service-based software systems could require to evolve during their execution. To support this, we need to consider system evolving since the design phase. Reflective Petri nets separate the system from its evolution by describing it and how it can evolve. However, reflective Petri nets have some expressivity limits and render overcomplicated the consistency checking necessary during service evolution. In this paper, we extend the reflective Petri nets approach to overcome such limits and show that on a case study.}, note = {} } @ARTICLE{Cazzola12b, author = {Pukall, Mario and K\"astner, Christian and Cazzola, Walter and G\"otz, Sebastian and Grebhahn, Alexander and Sch\"oter, Reimar and Saake, Gunter}, title = {{JavAdaptor --- Flexible Runtime Updates of Java Applications}}, journal = {{Software---Practice and Experience}}, publisher = {Wiley}, year = 2013, volume = 43, number = 2, pages = {153-185}, month = feb, pubtype = {journal}, url = {http://cazzola.di.unimi.it/pubs/swpe12-www.pdf}, keywords = {evolution sw-engineering}, abstract = {Software is changed frequently during its life cycle. New requirements come, and bugs must be fixed. To update an application, it usually must be stopped, patched, and restarted. This causes time periods of unavailability, which is always a problem for highly available applications. Even for the development of complex applications, restarts to test new program parts can be time consuming and annoying. Thus, we aim at dynamic software updates to update programs at runtime. There is a large body of research on dynamic software updates, but so far, existing approaches have shortcomings either in terms of flexibility or performance. In addition, some of them depend on specific runtime environments and dictate the program’s architecture. We present JavAdaptor, the first runtime update approach based on Java that (a) offers flexible dynamic software updates, (b) is platform independent, (c) introduces only minimal performance overhead, and (d) does not dictate the program architecture. JAVADAPTOR combines schema changing class replacements by class renaming and caller updates with Java HotSwap using containers and proxies. It runs on top of all major standard Java virtual machines. We evaluate our approach’s applicability and performance in non-trivial case studies and compare it with existing dynamic software update approaches.}, doi = {10.1002/spe.2107}, note = {} } @INPROCEEDINGS{Cazzola12c, author = {Cazzola, Walter}, title = {{Domain-Specific Languages in Few Steps: The Neverlang Approach}}, booktitle = {{Proceedings of the 11\textsuperscript{th} International Conference on Software Composition (SC'12)}}, year = 2012, editor = {Gschwind, Thomas and De Paoli, Flavio and Gruhn, Volker and Book, Matthias}, pages = {162-177}, address = {Prague, Czech Republic}, organization = {}, publisher = {Springer}, volume = {}, number = {}, series = {Lecture Notes in Computer Science 7306}, month = may#"-"#jun, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/sc12-www.pdf}, keywords = {AOP modularity dsl}, abstract = {Often an ad hoc programming language integrating features from different programming languages and paradigms represents the best choice to express a concise and clean solution to a problem. But, developing a programming language is not an easy task and this often discourages from developing your problem-oriented or domain-specific language. To foster DSL development and to favor clean and concise problem-oriented solutions we developed Neverlang. The Neverlang framework provides a mechanism to build custom programming languages up from features coming from different languages. The composability and flexibility provided by Neverlang permit to develop a new programming language by simply composing features from previously developed languages and reusing the corresponding support code (parsers, code generators, ...). In this work, we explore the Neverlang framework and try out its benefits in a case study that merges functional programming à la Python with coordination for distributed programming as in Linda.}, note = {} } @INPROCEEDINGS{Cazzola12d, author = {Cazzola, Walter and Vacchi, Edoardo}, title = {{DEXTER and Neverlang: A Union Towards Dynamicity}}, booktitle = {{Proceedings of the 7\textsuperscript{th} Workshop on the Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems (ICOOOLPS'12)}}, year = 2012, editor = {Jul, Eric and Rogers, Ian and Zendra, Olivier}, pages = {}, address = {Beijing, China}, organization = {}, publisher = {ACM}, volume = {}, number = {}, series = {}, month = jun, pubtype = {workshop}, keywords = {AOP dsl}, abstract = {}, note = {} } @INPROCEEDINGS{Cazzola13, author = {Cazzola, Walter and Vacchi, Edoardo}, title = {{Fine-Grained Annotations for Pointcuts with a Finer Granularity}}, booktitle = {{Proceedings of the 28\textsuperscript{th} Annual ACM Symposium on Applied Computing (SAC'13)}}, year = 2013, editor = {}, pages = {1709-1714}, address = {Coimbra, Portugal}, organization = {}, publisher = {ACM Press}, volume = {}, number = {}, series = {}, month = mar, pubtype = {conference}, url = {http://dl.acm.org/authorize?6813716}, keywords = {AOP meta-data}, abstract = {A number of authors have suggested that AspectJ-like pointcut languages are too limited, and that they cannot select every possible join point in a program. Many enhanced pointcut languages have been proposed; they require virtually no change to the original code, but their improved expressive power comes often at the cost of making the pointcut expression too tightly connected with the structure of the programs that are being advised. Other solutions consist in simple extensions to the base language; they require only small changes to the original code, but they frequently serve no other immediate purpose than exposing pieces of code to the weaver. Annotations are a form of metadata that has been introduced in Java 5. Annotations have a number of uses: they may provide hints to the compiler, information to code processing tools and they can be retained at runtime. At the moment of writing, runtime-accessible annotations in the Java programming language can only be applied to classes, fields and methods. The support to annotate expressions and blocks feels like a natural extension to Java's annotation model, that can be also exploited to expose join points at a finer-grained level. In this paper we present an extension to the @AspectJ language to select block and expression annotations in the @Java language extension.}, note = {} } @INPROCEEDINGS{Cazzola13b, author = {Cazzola, Walter and Vacchi, Edoardo}, title = {{@Java: Annotations in Freedom}}, booktitle = {{Proceedings of the 28th Annual ACM Symposium on Applied Computing (SAC'13)}}, year = 2013, editor = {}, pages = {1691-1696}, address = {Coimbra, Portugal}, organization = {}, publisher = {ACM Press}, volume = {}, number = {}, series = {}, month = mar, pubtype = {conference}, url = {http://dl.acm.org/authorize?6813701}, keywords = {meta-data reflection}, abstract = {The ability to annotate code and, in general, the capability to attach arbitrary metadata to portions of a program are features that have become more and more common in programming languages. In fact, various programming techniques and tools exploit their explicit availability for a number of purposes, such as extracting documentation, guiding code profiling, enhancing the description of a data type, marking code for instrumentation (for instance, in aspect-oriented frameworks), and the list could go on. While support to attach metadata to code is not a new concept (programming platforms as CLOS and Smalltalk have pioneered in this field), consistent, pervasive APIs to define and manage code annotations are something comparatively recent on modern platforms like the .NET and Java. Annotations in Java make possible to attach custom, structured metadata to declarations of classes, fields and methods. With this work, we propose an extension to Java (named @Java) that has a richer annotation model, supporting code block and expression annotations. In other words, the granularity of annotations extends to the statement and expression level and does not limit to class, method and field declarations.}, note = {} } @INPROCEEDINGS{Cazzola13c, author = {Gonz\'alez, Sebasti\'an and Mens, Kim and Col\u{a}cioiu, Marius and Cazzola, Walter}, title = {{Context Traits: Dynamic Behaviour Adaptation through Run-Time Trait Recomposition}}, booktitle = {{Proceedings of the 12th International Conference on Aspect-Oriented Software Development (AOSD'13)}}, year = 2013, editor = {Kienzle, J{\"o}rg}, pages = {209-220}, address = {Fukuoka, Japan}, organization = {}, publisher = {ACM}, volume = {}, number = {}, series = {}, month = mar, pubtype = {conference}, url = {http://dl.acm.org/authorize?6800737}, keywords = {COP modularity}, abstract = {Context-oriented programming emerged as a new paradigm to support fine-grained dynamic adaptation of software behaviour according to the context of execution. Though existing context-oriented approaches permit the adaptation of individual methods, in practice behavioural adaptations to specific contexts often require the modification of groups of interrelated methods. Furthermore, existing approaches impose a composition semantics that cannot be adjusted on a domain-specific basis. The mechanism of traits seems to provide a more appropriate level of granularity for defining adaptations, and brings along a flexible composition mechanism that can be exploited in a dynamic setting. This paper explores how to achieve context-oriented programming by using traits as units of adaptation, and trait composition as a mechanism to introduce behavioural adaptations at run time. First-class contexts reify relevant aspects of the environment in which the application executes, and they directly influence the trait composition of the objects that make up the application. To resolve conflicts arising from dynamic composition of behavioural adaptations, programmers can explicitly encode composition policies. With all this, the notion of context traits offers a promising approach to implementing dynamically adaptable systems. To validate the context traits model we implemented a JavaScript library and conducted case studies on context-driven adaptability.}, note = {} } @INCOLLECTION{Cazzola13d, author = {Cazzola, Walter and Rossini, Nicole Alicia and Bennett, Phillipa and Pradeep Mandalaparty, Sai and France, Robert B.}, title = {{Fine-Grained Semi-Automated Runtime Evolution}}, booktitle = {{MoDELS@Run-Time}}, publisher = {Springer}, year = 2014, chapter = {}, pages = {237--258}, address = {}, editor = {Bencomo, Nelly and Chang, Betty and France, Robert B. and A{\ss}mann, Uwe}, volume = {}, number = {}, series = {Lecture Notes in Computer Science 8378}, type = {}, edition = {}, month = aug, pubtype = {inbook}, url = {}, keywords = {evolution models sw-engineering}, abstract = {}, note = {} } @INPROCEEDINGS{Cazzola13e, author = {Cazzola, Walter and Vacchi, Edoardo}, title = {{Neverlang 2: Componentised Language Development for the JVM}}, booktitle = {{Proceedings of the 12\textsuperscript{th} International Conference on Software Composition (SC'13)}}, year = 2013, editor = {Binder, Walter and Bodden, Eric and L\"owe, Welf}, pages = {17--32}, address = {Budapest, Hungary}, organization = {}, publisher = {Springer}, volume = {}, number = {}, series = {Lecture Notes in Computer Science 8088}, month = jun, pubtype = {conference}, url = {}, keywords = {modularity dsl}, abstract = {}, note = {} } @INPROCEEDINGS{Cazzola13f, author = {Cazzola, Walter and Rossini, Nicole Alicia and Al-Refai, Mohammed and France, Robert B.}, title = {{Fine-Grained Software Evolution using UML Activity and Class Models}}, booktitle = {{Proceedings of the 16\textsuperscript{th} International Conference on Model Driven Engineering Languages and Systems (MoDELS'13)}}, year = 2013, editor = {Moreira, Ana and Sch{\"a}tz, Bernhard}, pages = {271--286}, address = {Miami, FL, USA}, organization = {}, publisher = {Springer}, volume = {}, number = {}, series = {Lecture Notes in Computer Science 8107}, month = sep#"-"#oct, pubtype = {conference}, url = {}, keywords = {evolution models sw-engineering}, abstract = {}, note = {} } @INPROCEEDINGS{Cazzola13g, author = {Vacchi, Edoardo and Cazzola, Walter and Pillay, Suresh and Combemale, Beno{\^\i}t}, title = {{Variability Support in Domain-Specific Language Development}}, booktitle = {{Proceedings of 6\textsuperscript{th} International Conference on Software Language Engineering (SLE'13)}}, year = 2013, editor = {Erwig, Martin and Paige, Richard F. and Van Wyk, Eric}, pages = {76--95}, address = {Indianapolis, USA}, organization = {}, publisher = {Springer}, volume = {}, number = {}, series = {Lecture Notes on Computer Science 8225}, month = oct, pubtype = {conference}, url = {}, keywords = {lpl dsl modularity sw-engineering}, abstract = {}, note = {} } @INCOLLECTION{Cazzola13h, author = {Cazzola, Walter}, title = {{Evolution as «Reflections on the Design»}}, booktitle = {{MoDELS@Run-Time}}, publisher = {Springer}, year = 2014, chapter = {}, pages = {259--278}, address = {}, editor = {Bencomo, Nelly and Chang, Betty and France, Robert B. and A{\ss}mann, Uwe}, volume = {}, number = {}, series = {Lecture Notes in Computer Science 8378}, type = {}, edition = {}, month = aug, pubtype = {inbook}, url = {}, keywords = {evolution reflection design sw-engineering}, abstract = {}, note = {} } @INCOLLECTION{Cazzola13i, author = {Bennaceur, Amel and France, Robert and Tamburrelli, Giordano and Vogel, Thomas and Mosterman, Pieter J. and Cazzola, Walter and Costa, Fabio M. and Pierantonio, Alfonso and Tichy, Matthias and Ak\c{s}it, Mehmet and Emmanuelson, P\"ar and Gang, Huang and Georgantas, Nikolaos and Redlich, David}, title = {{Mechanisms for Leveraging Models at Runtime in Self-Adaptive Software}}, booktitle = {{MoDELS@Run-Time}}, publisher = {Springer}, year = 2014, chapter = {}, pages = {19--46}, address = {}, editor = {Bencomo, Nelly and Chang, Betty and France, Robert B. and A{\ss}mann, Uwe}, volume = {}, number = {}, series = {Lecture Notes in Computer Science 8378}, type = {}, edition = {}, month = aug, pubtype = {inbook}, url = {}, keywords = {models sw-engineering}, abstract = {}, note = {} } @INPROCEEDINGS{Cazzola14, author = {Al-Refai, Mohammed and Cazzola, Walter and France, Robert B.}, title = {{Using Models to Dynamically Refactor Runtime Code}}, booktitle = {{Proceedings of the 29\textsuperscript{th} Annual ACM Symposium on Applied Computing (SAC'14)}}, year = 2014, editor = {}, pages = {1108--1113}, address = {Gyeongju, South Korea}, organization = {ACM}, publisher = {}, volume = {}, number = {}, series = {}, month = mar, pubtype = {conference}, url = {http://dl.acm.org/authorize?N09544}, keywords = {models evolution sw-engineering}, abstract = {Modern software systems that play critical roles in society's infrastructures are often required to change at runtime so that they can continuously provide essential services in the dynamic environments they operate in. Updating open, distributed software systems at runtime is very challenging. Using runtime models as an interface for updating software at runtime can help developers manage the complexity of updating software while it is executing. To support this idea, we developed the \FGA framework that permits developers to update running software through changes made to UML models of the running software. In this paper, we address the following question: can the UML models be used to express any type of code change a developer desires? Specifically, we report our experience on applying Fowler's code refactoring catalog through model refactoring in the \FGA framework. The goal of this work is to show that the set of \FGA change operators is complete by showing that the refactorings at the source code level can be expressed as model changes in the \FGA approach.}, note = {} } @ARTICLE{Cazzola14b, author = {Cazzola, Walter and Vacchi, Edoardo}, title = {{@Java: Bringing a Richer Annotation Model to Java}}, journal = {{Computer Languages, Systems \& Structures}}, publisher = {Elsevier}, year = 2014, volume = 40, number = 1, pages = {2--18}, month = apr, pubtype = {journal}, url = {}, keywords = {meta-data reflection AOP}, abstract = {The ability to annotate code and, in general, the capability to attach arbitrary meta-data to portions of a program are features that have become more and more common in programming languages. Annotations in Java make it possible to attach custom, structured meta-data to declarations of classes, fields and methods. However, the mechanism has some limits: annotations can only decorate declarations and their instantiation can only be resolved statically. With this work, we propose an extension to Java (named @Java) with a richer annotation model, supporting code block and expression annotations, as well as dynamically evaluated members. In other words, in our model, the granularity of annotations extends to the statement and expression level and annotations may hold the result of runtime-evaluated expressions. Our extension to the Java annotation model is twofold: (i) we introduced block and expression annotations and (ii) we allow every annotation to hold dynamically evaluated values. Our implementation also provides an extended reflection API to support inspection and retrieval of our enhanced annotations.}, doi = {10.1016/j.cl.2014.02.002}, note = {} } @INPROCEEDINGS{Cazzola14c, author = {Vacchi, Edoardo and Olivares, Diego Mathias and Shaqiri, Albert and Cazzola, Walter}, title = {{Neverlang 2: A Framework for Modular Language Implementation}}, booktitle = {{Proceedings of the 13th International Conference on Modularity (Modularity'14)}}, year = 2014, editor = {}, pages = {23-26}, address = {Lugano, Switzerland}, organization = {}, publisher = {ACM}, volume = {}, number = {}, series = {}, month = apr, pubtype = {conference}, url = {http://dl.acm.org/authorizestats?N09543}, keywords = {dsl modularity}, abstract = {Neverlang 2 is a JVM-based framework for language development that emphasizes code reuse through composition of language features. This paper is aimed at showing how to develop extensible, custom languages using Neverlang's component-based model of implementation. Using this model, each feature of the language can be implemented as a separate, conceptually isolated unit that can be compiled and distributed separately from the others. A live tutorial of the framework can be found at \url{http://youtu.be/Szxvg7XLbXc}}, note = {} } @ARTICLE{Cazzola14d, author = {Cazzola, Walter and Vacchi, Edoardo}, title = {{On the Incremental Growth and Shrinkage of LR Goto-Graphs}}, journal = {{ACTA Informatica}}, publisher = {Springer}, year = 2014, volume = 51, number = 7, pages = {419--447}, month = oct, pubtype = {journal}, url = {http://link.springer.com/article/10.1007%2Fs00236-014-0201-2}, keywords = {dsl}, abstract = {The LR(0) goto-graph is the basis for the construction of parsers for several interesting grammar classes such as LALR and GLR. Early work has shown that even when a grammar is an extension to another, the goto-graph of the first is not necessarily a subgraph of the second. Some authors presented algorithms to grow and shrink these graphs incrementally, but the formal proof of the existence of a particular relation between a given goto-graph and a grown or shrunk counterpart seems to be still missing in literature as of today. In this paper we use the recursive projection of paths of limited length to prove the existence of one such relation, when the sets of productions are in a subset relation. We also use this relation to present two algorithms (Grow and Shrink) that transform the goto-graph of a given grammar into the goto-graph of an extension or a restriction to that grammar. We implemented these algorithms in a dynamically updatable LALR parser generator called DEXTER (the Dynamically EXTEnsible Recognizer) that we are now shipping with our current implementation of the Neverlang framework for programming language development.}, doi = {10.1007/s00236-014-0201-2}, note = {} } @INPROCEEDINGS{Cazzola14e, author = {Vacchi, Edoardo and Cazzola, Walter and Combemale, Beno{\^\i}t and Acher, Mathieu}, title = {{Automating Variability Model Inference for Component-Based Language Implementations}}, booktitle = {{Proceedings of the 18th International Software Product Line Conference (SPLC'14)}}, year = 2014, editor = {Heymans, Patrick and Rubin, Julia}, pages = {167--176}, address = {Florence, Italy}, organization = {}, publisher = {ACM}, volume = {}, number = {}, series = {}, month = sep, pubtype = {conference}, url = {http://dl.acm.org/authorize?N09542}, keywords = {lpl dsl modularity sw-engineering}, abstract = {Recently, domain-specific language development has become again a topic of interest, as a means to help designing solutions to domain-specific problems. Componentized language frameworks, coupled with variability modeling, have the potential to bring language development to the masses, by simplifying the configuration of a new language from an existing set of reusable components. However, designing variability models for this purpose requires not only a good understanding of these frameworks and the way components interact, but also an adequate familiarity with the problem domain. In this paper we propose an approach to automatically infer a relevant variability model from a collection of already implemented language components, given a structured, but general representation of the domain. We describe techniques to assist users in achieving a better understanding of the relationships between language components, and find out which languages can be derived from them with respect to the given domain.}, note = {} } @ARTICLE{Cazzola15, author = {Cazzola, Walter and Marchetto, Alessandro}, title = {{A Concern-Oriented Framework for Dynamic Measurements}}, journal = {{Information and Software Technology}}, publisher = {Elsevier}, year = 2015, volume = 57, number = {}, pages = {32--51}, month = jan, pubtype = {journal}, url = {http://cazzola.di.unimi.it/pubs/ist15-published.pdf}, keywords = {metrics AOP sw-engineering}, abstract = {Evolving software programs requires that software developers reason \textit{quantitatively} about the modularity impact of several concerns, which are often scattered over the system. To this respect, concern-oriented software analysis is rising to a dominant position in software development. Hence, measurement techniques play a fundamental role in assessing the concern modularity of a software system. Unfortunately, existing measurements are still fundamentally module-oriented rather than concern-oriented. Moreover, the few available concern-oriented metrics are defined in a non-systematic and shared way and mainly focus on static properties of a concern, even if many properties can only be accurately quantified at run-time. Hence, novel concern-oriented measurements and, in particular, shared and systematic ways to define them are still welcome. This paper poses the basis for a unified framework for concern-driven measurement. The framework provides a basic terminology and criteria for defining novel concern metrics. To evaluate the framework feasibility and effectiveness, we have shown how it can be used to adapt some classic metrics to quantify concerns and in particular to instantiate new dynamic concern metrics from their static counterparts.}, doi = {10.1016/j.infsof.2014.08.006}, note = {} } @INPROCEEDINGS{Cazzola15b, author = {Chitchyan, Ruzanna and Cazzola, Walter and Rashid, Awais}, title = {{Engineering Sustainability through Language}}, booktitle = {{Proceedings of the 37th International Conference on Software Engineering (ICSE'15)}}, year = 2015, editor = {}, pages = {501--504}, address = {Firenze, Italy}, organization = {}, publisher = {IEEE}, volume = {}, number = {}, series = {}, month = may, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/icse15-seis-published.pdf}, keywords = {dsl modularity evolution sw-engineering}, abstract = {As our understanding and care for sustainability concerns increases, so does the demand for incorporating these concerns into software. Yet, existing programming language constructs are not well-aligned with concepts of the sustainability domain. This undermines what we term \emph{technical sustainability of the software} due to (i) increased complexity in programming of such concerns and (ii) continuous code changes to keep up with changes in (environmental, social, legal and other) sustainability-related requirements. In this paper we present a proof-of-concept approach on how technical sustainability support for new and existing concerns can be provided through flexible language-level progr amming. We propose to incorporate sustainability-related behaviour into programs through \emph{micro-languages} enabling such behaviour to be updated and/or redefined as and wh en required.}, note = {Track on Software Engineering in Society} } @ARTICLE{Cazzola15c, author = {Vacchi, Edoardo and Cazzola, Walter}, title = {{Neverlang: A Framework for Feature-Oriented Language Development}}, journal = {{Computer Languages, Systems \& Structures}}, publisher = {Elsevier}, year = 2015, volume = 43, number = 3, pages = {1--40}, month = oct, pubtype = {journal}, url = {http://cazzola.di.unimi.it/pubs/comlan15-published.pdf}, keywords = {dsl modularity sw-engineering}, abstract = {Reuse in programming language development is an open research problem. Many authors have proposed frameworks for modular language development. These frameworks focus on maximiz ing code reuse, providing primitives for componentizing language implementations. There is also an open debate on combining feature-orientation with modular language developme nt. Feature-oriented programming is a vision of computer programming in which features can be implemented separately, and then combined to build a variety of software products. How ever, even though feature-orientation and modular programming are strongly connected, modular language development frameworks are not usually meant primarily for feature-orient ed language definition. In this paper we present a model of language development that puts feature implementation at the center, and describe its implementation in the Neverla ng framework. The model has been evaluated through several languages implementations: in this paper, a state machine language is used as a means of comparison with other framew orks, and a JavaScript interpreter implementation is used to further illustrate the benefits that our model provides.}, doi = {10.1016/j.cl.2015.02.001}, note = {} } @INPROCEEDINGS{Cazzola15d, author = {Paterson, James and Law, Robert and Cazzola, Walter and Malchiodi, Dario and Karhu, Markku and Illina, Irina and Maximiano, Marisa and Silva, Catarina}, title = {{Experience of an International Collaborative Project with First Year Programming Students}}, booktitle = {{Proceedings of the IEEE 39th Annual Computer Software and Applications Conference (COMPSAC'15)}}, year = 2015, editor = {}, pages = {829--834}, address = {Taichung, Taiwan}, organization = {}, publisher = {IEEE}, volume = {}, number = {}, series = {}, month = jul, pubtype = {conference}, url = {}, new = {}, keywords = {learning programming}, abstract = {}, doi = {}, note = {} } @INPROCEEDINGS{Cazzola15f, author = {Kühn, Thomas and Cazzola, Walter and Olivares, Diego Mathias}, title = {{Choosy and Picky: Configuration of Language Product Lines}}, booktitle = {{Proceedings of the 19th International Software Product Line Conference (SPLC'15)}}, year = 2015, editor = {Botterweck, Goetz and White, Jules}, pages = {71--80}, address = {Nashville, TN, USA}, organization = {}, publisher = {ACM}, volume = {}, number = {}, series = {}, month = jul, pubtype = {conference}, url = {http://dl.acm.org/authorize?N09541}, keywords = {lpl dsl modularity sw-engineering}, abstract = {Although most programming languages naturally share several language features, they are typically implemented as a monolithic product. Language features cannot be plugged and unplugged from a language and reused in another language. Some modular approaches to language construction do exist but composing language features requires a deep understanding of its implementation hampering their use. The choose and pick approach from software product lines provides an easy way to compose a language out of a set of language features. However, current approaches to language product lines are not sufficient enough to cope with the complexity and evolution of real world programming languages. In this work, we propose a general light-weight bottom-up approach to automatically extract a feature model from a set of tagged language components. We applied this approach to the Neverlang language development framework and developed the AiDE tool to guide language developers towards a valid language composition. The approach has been evaluated on a decomposed version of Javascript to highlight the benefits of such a language product line.}, note = {} } @ARTICLE{Cazzola16, author = {Cazzola, Walter and Olivares, Diego Mathias}, title = {{Gradually Learning Programming Supported by a Growable Programming Language}}, journal = {{IEEE Transactions on Emerging Topics in Computing}}, year = 2016, volume = 4, number = 3, pages = {404--415}, month = sep, pubtype = {journal}, url = {http://cazzola.di.unimi.it/pubs/tetc16-published.pdf}, keywords = {dsl modularity sw-engineering learning}, abstract = {Learning programming is a difficult task. The learning process is particularly disorienting when you are approaching programming for the first time. As a student you are exposed to several new concepts (control flow, variable, etc. but also coding, compiling etc.) and new ways to think (algorithms). Teachers try to expose the students gradually to the new concepts by presenting them one by one but the tools at student's disposal do not help: they provide support, suggestion and documentation for the full programming language of choice hampering the teacher's efforts. On the other side, students need to learn real languages and not didactic languages. In this work we propose an approach to gradually teaching programming supported by a programming language that grows---together with its implementation---along with the number of concepts presented to the students. The proposed approach can be applied to the teaching of any programming language and some experiments with Javascript are reported}, doi = {10.1109/TETC.2015.2446192}, note = {Special Issue on Emerging Trends in Education} } @INPROCEEDINGS{Cazzola16b, author = {Al-Refai, Mohammed and Cazzola, Walter and Ghosh, Sudipto and France, Robert}, title = {{Using Models to Validate Unanticipated, Fine-Grained Adaptations at Runtime}}, booktitle = {{Proceedings of the 17th IEEE International Symposium on High Assurance Systems Engineering (HASE'16)}}, year = 2016, editor = {Waeselynck, Helene and Babiceanu, Radu}, pages = {23--30}, address = {Orlando, FL, USA}, organization = {}, publisher = {IEEE}, volume = {}, number = {}, series = {}, month = jan, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/hase16-published.pdf}, keywords = {testing models evolution sw-engineering}, abstract = {An increasing number of modern software systems need to be adapted at runtime while they are still executing. It becomes crucial to validate each adaptation before it is deployed to the running system. Models are used to ease software maintenance and can, therefore, be used to manage dynamic software adaptations. For example, models are used to manage coarse-grained anticipated adaptations for self-adaptive systems. However, the need for both fine-grained and unanticipated adaptations is becoming increasingly common, and their validation is also becoming more crucial. This paper proposes an approach to validate unanticipated, fine-grained adaptations performed on models before the adaptations are deployed into the running system. The proposed approach exploits model execution where model representations of the test suites of a software system are executed. The proposed approach is demonstrated and evaluated within the Fine Grained Adaptation (FiGA) framework.}, note = {} } @ARTICLE{Cazzola16c, author = {Cazzola, Walter and Vacchi, Edoardo}, title = {{Language Components for Modular DSLs using Traits}}, journal = {{Computer Languages, Systems \& Structures}}, publisher = {Elsevier}, year = 2016, volume = 45, number = {}, pages = {16--34}, month = apr, doi = {10.1016/j.cl.2015.12.001}, pubtype = {journal}, url = {http://cazzola.di.unimi.it/pubs/comlan16-published.pdf}, keywords = {dsl modularity sw-engineering}, abstract = {Recent advances in tooling and modern programming languages have progressively brought back the practice of developing domain-specific languages as a means to improve software development. Consequently, the problem of making composition between languages easier by emphasizing code reuse and componentized programming is a topic of increasing interest in research. In fact, it is not uncommon for different languages to share common features, and, because in the same project different DSLs may coexist to model concepts from different problem areas, it is interesting to study ways to develop modular, extensible languages. Earlier work has shown that traits can be used to modularize the semantics of a language implementation; a lot of attention is often spent on embedded DSLs; even when external DSLs are discussed, the main focus is on modularizing the semantics. In this paper we will show a complete trait-based approach to modularize not only the semantics but also the syntax of external DSLs, thereby simplifying extension and therefore evolution of a language implementation. We show the benefits of implementing these techniques using the Scala programming language.}, note = {} } @INPROCEEDINGS{Cazzola16d, author = {Al-Refai, Mohammed and Ghosh, Sudipto and Cazzola, Walter}, title = {{Model-based Regression Test Selection for Validating Runtime Adaptation of Software Systems}}, booktitle = {{Proceedings of the 9th IEEE International Conference on Software Testing, Verification and Validation (ICST'16)}}, year = 2016, editor = {Briand, Lionel and Khurshid, Sarfraz}, pages = {288--298}, address = {Chicago, IL, USA}, organization = {}, publisher = {IEEE}, volume = {}, number = {}, series = {}, month = apr, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/icst16-published.pdf}, keywords = {testing models evolution sw-engineering}, abstract = {An increasing number of modern software systems need to be adapted at runtime without stopping their execution. Runtime adaptations can introduce faults in existing functionality, and thus, regression testing must be conducted after an adaptation is performed but before the adaptation is deployed to the running system. Regression testing must be completed subject to time and resource constraints. Thus, test selection techniques are needed to reduce the cost of regression testing. The FiGA framework provides a complete loop from code to models and back that allows fine-grained model-based adaptation and validation of running Java systems without stopping their execution. In this paper we present a model-based test selection approach for regression testing during the validation activity to be used with the FiGA framework. The evaluation results show that our approach was able to reduce the number of selected test cases, and that the model-level fault detection ability of the selected test cases was never lower than that of the original test cases.}, note = {} } @INPROCEEDINGS{Cazzola16e, author = {Cazzola, Walter and Shaqiri, Albert}, title = {{Modularity and Optimization in Synergy}}, booktitle = {{Proceedings of the 15th International Conference on Modularity (Modularity'16)}}, year = 2016, editor = {Batory, Don}, pages = {70--81}, address = {M\'alaga, Spain}, organization = {}, publisher = {ACM}, volume = {}, number = {}, series = {}, month = mar, pubtype = {conference}, url = {http://dl.acm.org/authorize?N13912}, keywords = {dsl modularity sw-engineering}, abstract = {As with traditional software, the complexity of a programming language implementation is faced with modularization which favors the separation of concerns, independent development, maintainability and reuse. However, modularity interferes with language optimization as the latter requires context information that crosses over the single module boundaries and involves other modules. This renders hard to provide the optimization for a single language concept to be reusable with the concept itself. Therefore, the optimization is in general postponed to when all language concepts are available. We defined a model for modular language development with a multiple semantic actions dispatcher based on condition guards that are evaluated at runtime. The optimization can be implemented as context-dependent extensions applied a posteriori to the composed language interpreter without modifying a single component implementation. This renders effective the defined optimization within the language concept boundaries according to the context provided by other language concepts when available and eases its reuse with the language concepts implementation independently of its usage context. The presented model is integrated into the Neverlang development framework and is demonstrated on the optimization of a Javascript interpreter written in Neverlang. We also discuss the applicability of our model to other frameworks for modular language development.}, note = {} } @ARTICLE{Cazzola16f, author = {Gini, Rosa and Schuemie, Martijn and Brown, Jeffrey and Ryan, Patrick and Vacchi, Edoardo and Coppola, Massimo and Cazzola, Walter and Coloma, Preciosa and Berni, Roberto and Diallo, Gayo and Oliveira, Jos\'e Luis and Avillach, Paul and Trifir\`o, Gianluca and Rijnbeek, Peter and Bellentani, Mariadonata and van Der Lei, Johan and Klazinga, Niek and Sturkenboom, Miriam}, title = {{Data Extraction and Management in Networks of Observational Health Care Databases for Scientific Research: A Comparison among EU-ADR, OMOP, Mini-Sentinel and MATRICE Strategies}}, journal = {{Generating Evidence \& Methods to improve patient outcomes (eGEMs)}}, year = 2016, volume = 4, number = 1, pages = {1189--1212}, month = feb, doi = {10.13063/2327-9214.1189}, pubtype = {journal}, url = {http://repository.edm-forum.org/egems/vol4/iss1/2/}, keywords = {dsl sw-engineering e-health}, abstract = {Intrduction. To achieve fast and transparent production of empirical evidence in healthcare research we see increased use of existing observational data. Multiple databases are often used, to increase power or assess rare exposures or outcomes or study diverse populations. For privacy and sociological reasons, original data on individualsubjects can’t be shared, requiring a distributed network approach where data processing is performed prior to data sharing. Case Descriptions and Variation Among Sites. We created a conceptual framework distinguishing three steps in local data processing: (1) data reorganization into a data structure common across the network; (2) derivation of study variables not present in original data; (3) application of study design to transform longitudinal data into aggregated datasets for statistical analysis. We applied this framework to four case studies to identify similarities and differences in the United States and Europe: EU-ADR, OMOP, Mini-Sentinel and MATRICE. Findings. National networks (OMOP, Mini-Sentinel, MATRICE) all adopted shared procedures for local data reorganization. The multinational EU-ADR network needed locally-defined procedures to reorganize its heterogeneous data into a common structure. Derivation of new data elements was centrally-defined in all networks but the procedure was not shared in EU-ADR. Application of study design was automated and shared in all the case studies. Computer procedures were embodied in different programming languages, including SAS, R, SQL, Java and C++. Conclusion. Using our conceptual framework we identified several areas that would benefit from research to identify optimal standards for production of empirical knowledge from existing databases.}, note = {} } @INPROCEEDINGS{Cazzola16g, author = {Cazzola, Walter and Shaqiri, Albert}, title = {{Dynamic Software Evolution through Interpreter Adaptation}}, booktitle = {{Proceedings of the 15th International Conference on Modularity (Modularity'16)}}, year = 2016, editor = {}, pages = {16--19}, address = {M\'alaga, Spain}, organization = {}, publisher = {ACM}, volume = {}, number = {}, series = {}, month = mar, pubtype = {conference}, url = {http://dl.acm.org/authorize?N13911}, keywords = {dsl modularity sw-engineering evolution}, abstract = {Significant research has been dedicated to dynamic software evolution and adaptation that lead to different approaches which can mainly be categorized as either architecture-based or language-based. But there was little or no focus on dynamic evolution achieved through language interpreter adaptation. In this paper we present a model for such adaptations and illustrate their applicability and usefulness on practical examples developed in Neverlang, a framework for modular language development with features for dynamic adaptation of language interpreters.}, note = {} } @ARTICLE{Cazzola16h, author = {Cazzola, Walter and Giannini, Paola and Shaqiri, Albert}, title = {{Formal Attributes Traceability in Modular Language Development Frameworks}}, journal = {{Electric Notes In Theoretical Computer Science}}, publisher = {Elsevier}, year = 2016, volume = 322, number = {}, pages = {119--134}, month = apr, doi = {doi.org/10.1016/j.entcs.2016.03.009}, pubtype = {journal}, url = {http://cazzola.di.unimi.it/pubs/entcs16-published.pdf}, keywords = {modularity}, abstract = {Modularization and component reuse are concepts that can speed up the design and implementation of domain specific languages. Several modular development frameworks have been developed that rely on attributes to share information among components. Unfortunately, modularization also fosters development in isolation and attributes could be undefined or used inconsistently due to a lack of coordination. This work presents 1) a type system that permits to trace attributes and statically validate the composition against attributes lack or misuse and 2) a correct and complete type inference algorithm for this type system. The type system and inference are based on the Neverlang development framework but it is also discussed how it can be used with different frameworks.}, note = {} } @INPROCEEDINGS{Cazzola16i, author = {Kühn, Thomas and Cazzola, Walter}, title = {{Apples and Oranges: Comparing Top-Down and Bottom-Up Language Product Lines}}, booktitle = {{Proceedings of the 20th International Software Product Line Conference (SPLC'16)}}, year = 2016, editor = {Rabiser, Rick and Xie, Bing}, pages = {50--59}, address = {Beijing, China}, organization = {}, publisher = {ACM}, volume = {}, number = {}, series = {}, month = sep, pubtype = {conference}, url = {http://dl.acm.org/authorize?N13910}, keywords = {lpl dsl modularity sw-engineering}, abstract = {Over the past decade language development tools have been significantly improved. This permitted both practitioners and researchers to design a wide variety of domain-specific languages (DSL) and extensions to programming languages. Moreover, multiple researchers have combined different language variants to form families of DSLs as well as programming languages. Unfortunately, current language development tools cannot directly support the development of these families. To overcome this limitation, researchers have recently applied ideas from software product lines (SPL) to create product lines of compilers/interpreters for language families, denoted language product lines (LPL). Similar to SPLs, however, these product lines can be created either using a top-down or a bottom-up approach. Yet, there exist no case study comparing the suitability of both approaches to the development of LPLs, making it unclear how language development tools should evolve. Accordingly, this paper compares both feature modeling approaches by applying them to the development of an LPL for the family of role-based programming languages and discussing their applicability, feasibility and overall suitability for the development of LPLs. Although one might argue that this compares apples and oranges, we believe that this case still provides crucial insights into the requirements, assumptions, and challenges of each approach.}, note = {} } @INPROCEEDINGS{Cazzola16j, author = {Cazzola, Walter and Jalili, Mehdi}, title = {{Dodging Unsafe Update Points in Java Dynamic Updating Systems}}, booktitle = {{Proceedings of the 27th International Symposium on Software Reliability Engineering (ISSRE'16)}}, year = 2016, editor = {Romanovsky, Alexander and Troubitsyna, Elena}, pages = {332--341}, address = {Ottawa, Canada}, organization = {IEEE}, publisher = {}, volume = {}, number = {}, series = {}, month = oct, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/issre16-published.pdf}, keywords = {evolution meta-data sw-engineering}, abstract = {Dynamic Software Updating (DSU) provides mechanisms to update a program without stopping its execution. An indiscriminate update, that does not consider the current state of the computation, potentially undermines the stability of the running application. To automatically determine a safe moment when to update the running system is still an open problem often neglected from the existing DSU systems. This paper proposes a mechanism to support the choice of a safe update point by marking which point can be considered unsafe and therefore dodged during the update. The method is based on decorating the code with some specific meta-data that can be used to find the right moment to do the update. The proposed approach has been implemented as an external component that can be plugged into every DSU system. The approach is demonstrated on the evolution of the HSQLDB system from two distinct versions to their next update.}, note = {} } @ARTICLE{Cazzola17, author = {Cazzola, Walter and Shaqiri, Albert}, title = {{Open Programming Language Interpreters}}, journal = {{The Art, Science, and Engineering of Programming Journal}}, publisher = {{AOSA}}, year = 2017, volume = 1, number = 2, pages = {5-1--5-34}, month = apr, doi = {10.22152/programming-journal.org/2017/1/5}, pubtype = {journal}, url = {https://arxiv.org/pdf/1703.10873}, keywords = {dsl modularity evolution sw-engineering}, abstract = {\textbf{Context:} This paper presents the concept of open programming language interpreters and the implementation of a framework-level metaobject protocol (MOP) to support them. \textbf{Inquiry:} We address the problem of dynamic interpreter adaptation to tailor the interpreter's behavior on the task to be solved and to introduce new features to fulfill unforeseen requirements. Many languages provide a MOP that to some degree supports reflection. However, MOPs are typically language-specific, their reflective functionality is often restricted, and the adaptation and application logic are often mixed which hardens the understanding and maintenance of the source code. Our system overcomes these limitations. \textbf{Approach:} We designed and implemented a system to support open programming language interpreters. The prototype implementation is integrated in the Neverlang framework. The system exposes the structure, behavior and the runtime state of any Neverlang-based interpreter with the ability to modify it. \textbf{Knowledge:} Our system provides a complete control over interpreter's structure, behavior and its runtime state. The approach is applicable to every Neverlang-based interpreter. Adaptation code can potentially be reused across different language implementations. \textbf{Grounding:} Having a prototype implementation we focused on feasibility evaluation. The paper shows that our approach well addresses problems commonly found in the research literature. We have a demonstrative video and examples that illustrate our approach on dynamic software adaptation, aspect-oriented programming, debugging and context-aware interpreters. \textbf{Importance:} To our knowledge, our paper presents the first reflective approach targeting a general framework for language development. Our system provides full reflective support for free to any Neverlang-based interpreter. We are not aware of any prior application of open implementations to programming language interpreters in the sense defined in this paper. Rather than substituting other approaches, we believe our system can be used as a complementary technique in situations where other approaches present serious limitations.}, note = {} } @INPROCEEDINGS{Cazzola17b, author = {Al-Refai, Mohammed and Cazzola, Walter and Ghosh, Sudipto}, title = {{A Fuzzy Logic Based Approach for Model-based Regression Test Selection}}, booktitle = {{Proceedings of the 20\textsuperscript{th} International Conference on Model Driven Engineering Languages and Systems (MoDELS'17)}}, year = 2017, editor = {Gray, Jeff and Kulkarni, Vinay}, pages = {55--62}, address = {Austin, TX, USA}, organization = {}, publisher = {IEEE}, volume = {}, number = {}, series = {}, month = sep, doi = {10.1109/MODELS.2017.17}, pubtype = {conference}, url = {http://cazzola.di.unimi.it/pubs/models17-published.pdf}, keywords = {testing models sw-engineering}, abstract = {Regression testing is performed to verify that previously developed functionality of a software system is not broken when changes are made to the system. Since executing all the existing test cases can be expensive, regression test selection (RTS) approaches are used to select a subset of them, thereby improving the efficiency of regression testing. Model-based RTS approaches select test cases on the basis of changes made to the models of a software system. While these approaches are useful in projects that already use model-driven development methodologies, a key obstacle is that the models are generally created at a high level of abstraction. They lack the information needed to build traceability links between the models and the coverage-related execution traces from the code-level test cases. In this paper, we propose a fuzzy logic based approach named FLiRTS, for UML model-based RTS. FLiRTS automatically refines abstract UML models to generate multiple detailed UML models that permit the identification of the traceability links. The process introduces a degree of uncertainty, which is addressed by applying fuzzy logic based on the refinements to allow the classification of the test cases as retestable according to the probabilistic correctness associated with the used refinement. The potential of using FLiRTS is demonstrated on a simple case study. The results are promising and comparable to those obtained from a model-based approach (MaRTS) that requires detailed design models, and a code-based approach (DejaVu).}, note = {} } @ARTICLE{Cazzola17c, author = {Cazzola, Walter and Chitchyan, Ruzanna and Rashid, Awais and Shaqiri, Albert}, title = {{$\mu$-DSU: A Micro-Language Based Approach to Dynamic Software Updating}}, journal = {{Computer Languages, Systems \& Structures}}, publisher = {Elsevier}, year = 2018, volume = 51, number = {}, pages = {71--89}, month = jan, doi = {10.1016/j.cl.2017.07.003}, pubtype = {journal}, url = {}, new = {}, keywords = {dsl evolution}, abstract = { Today software systems play a critical role in society’s infrastructures and many are required to provide uninterrupted services in their constantly changing environments. As the problem domain and the operational context of such software changes, the software itself must be updated accordingly. In this paper we propose to support dynamic software updating through language semantic adaptation; this is done through use of micro-languages that confine the effect of the introduced change to specific application features. Micro-languages provide a logical layer over a programming language and associate an application feature with the portion of the programming language used to implement it. Thus, they permit to update the application feature by updating the underlying programming constructs without affecting the behaviour of the other application features. Such a linguistic approach provides the benefit of easy addition/removal of application features (with a special focus on non-functional features) to/from a running application by separating the implementation of the new feature from the original application, allowing for the application to remain unaware of any extensions. The feasibility of this approach is demonstrated with two studies; its benefits and drawbacks are also analysed.}, note = {} } @ARTICLE{Cazzola17d, author = {Cazzola, Walter and Shaqiri, Albert}, title = {{Context-Aware Software Variability through Adaptable Interpreters}}, journal = {{IEEE Software}}, publisher = {IEEE}, year = 2017, volume = 34, number = 6, pages = {83--88}, month = nov, doi = {10.1109/MS.2017.4121222}, pubtype = {journal}, url = {http://cazzola.di.unimi.it/pubs/ieeesw17-published.pdf}, keywords = {dsl COP modularity sw-engineering evolution}, abstract = {A proposed approach moves variability support from the programming language to the language implementation level. This enables contextual variability in any application independently of whether the underlying language supports context-oriented programming. A Neverlang-based prototype implementation illustrates this approach.}, note = {Special Issue on Context Variability Modeling} } @ARTICLE{Cazzola17e, author = {Al-Refai, Mohammed and Ghosh, Sudipto and Cazzola, Walter}, title = {{Supporting Inheritance Hierarchy Changes in Model-based Regression Test Selection}}, journal = {{Software and Systems Modeling}}, publisher = {Springer}, year = 2019, volume = 18, number = 2, pages = {937--958}, month = apr, doi = {10.1007/s10270-017-0636-3}, pubtype = {journal}, url = {http://em.rdcu.be/wf/click?upn=KP7O1RED-2BlD0F9LDqGVeSCHFLcLtrgCHRXY4z8BWA5I-3D_6SgQd84sYrLRYBsEhNDV7OJUxaQwZo-2F4JHHMgbl-2FafqowFa2D7HeWbbHlW3dphDJw0oC4MIZThIYfE4hHvJWm7cJZ3r-2BaSL95Bk5772M5yKuzaYZw-2B1JpkajuJqrGc9tce3ait2sHmfvCYFkG0DvcqWR8PlZRREvDyMfed8HqH6OQQhoO-2BTwhyIVy9PkhD1bxd983yDMOe4pRmPyEUkbxobSA6I4b9gCxygYi8T9iDlQcPWg8gPDko8P76T0Bd8vWR-2F2O61LB72ilz7npQ5iQA-3D-3D}, new = {}, keywords = {testing models sw-engineering}, abstract = {Models can be used to ease and manage the development, evolution, and runtime adaptation of a software system. When models are adapted, the resulting models must be rigorously tested. Apart from adding new test cases, it is also important to perform regression testing to ensure that the evolution or adaptation did not break existing functionality. Since regression testing is performed with limited resources and under time constraints, regression test selection (RTS) techniques are needed to reduce the cost of regression testing. Applying model-level RTS for model-based evolution and adaptation is more convenient than using code-level RTS because the test selection process happens at the same level of abstraction as that of evolution and adaptation. In earlier work, we proposed a model-based RTS approach called MaRTS to be used with a fine-grained model-based adaptation framework that targets applications implemented in Java. MaRTS uses UML models consisting of class and activity diagrams. It classifies test cases as obsolete, reusable, or retestable based on changes made to UML class and activity diagrams of the system being adapted. However, MaRTS did not take into account the changes made to the inheritance hierarchy in the class diagram and the impact of these changes on the selection of test cases. This paper extends MaRTS to support such changes and demonstrates that the extended approach performs as well as or better than code-based RTS approaches in safely selecting regression test cases. While MaRTS can generally be used during any model-driven development or model-based evolution activity, we have developed it in the context of runtime adaptation. We evaluated the extended MaRTS on a set of applications and compared the results with code-based RTS approaches that also support changes to the inheritance hierarchy. The results showed that the extended MaRTS selected all the test cases relevant to the inheritance hierarchy changes and that the fault detection ability of the selected test cases was never lower than that of the baseline test cases. The extended MaRTS achieved comparable results to a graph-walk code-based RTS approach (DejaVu) and showed a higher reduction in the number of selected test cases when compared with a static analysis code-based RTS approach (ChEOPSJ).}, note = {Special Issue on Model-Based Testing} } @INPROCEEDINGS{Cazzola18b, author = {Kühn, Thomas and Kassin, Ivo and Cazzola, Walter and A{\ss}mann, Uwe}, title = {{Modular Feature-Oriented Graphical Editor Product Lines}}, booktitle = {{Proceedings of the 22nd International Software Product Line Conference (SPLC'18)}}, year = 2018, editor = {Borba, Paulo and Berger, Thorsten}, pages = {76--86}, address = {Gothenburg, Sweden}, organization = {}, publisher = {ACM}, volume = {}, number = {}, series = {}, month = sep, pubtype = {conference}, url = {}, new = {}, keywords = {lpl dsl modularity sw-engineering}, abstract = {}, note = {} } @ARTICLE{Cazzola18c, author = {Combemale, Beno{\^\i}t and Kienzle, J\"org and Mussbacher, Gunter and Barais, Olivier and Bousse, Erwan and Cazzola, Walter and Collet, Philippe and Degueule, Thomas and Heinrich, Robert and J\'ez\'equel, Jean-Marc and Leduc, Manuel and Mayerhofer, Tanja and Mosser, S\'ebastien and Sch\"ottle, Matthias and Strittmatter, Misha and Wortmann, Andreas}, title = {{Concern-Oriented Language Development (COLD): Fostering Reuse in Language Engineering}}, journal = {{Computer Languages, Systems \& Structures}}, publisher = {Elsevier}, year = 2018, volume = 54, number = {}, pages = {139--155}, month = dec, pubtype = {journal}, url = {}, keywords = {lpl dsl modularity sw-engineering}, abstract = {Domain-Specific Languages (DSLs) bridge the gap between the problem space, in which stakeholders work, and the solution space, i.e., the concrete artifacts defining the target system. They are usually small and intuitive languages whose concepts and expressiveness fit a particular domain. DSLs recently found their application in an increasingly broad range of domains, e.g., cyber-physical systems, computational sciences and high performance computing. Despite recent advances, the development of DSLs is error-prone and requires substantial engineering efforts. Techniques to reuse from one DSL to another and to support customization to meet new requirements are thus particularly welcomed. Over the last decade, the Software Language Engineering (SLE) community has proposed various reuse techniques. However, all these techniques remain disparate and complicate the development of real-world DSLs involving different reuse scenarios. In this paper, we introduce the Concern-Oriented Language Development (COLD) approach, a new language development model that promotes modularity and reusability of language concerns. A language concern is a reusable piece of language that consists of usual language artifacts (e.g., abstract syntax, concrete syntax, semantics) and exhibits three specific interfaces that support (1) variability management, (2) customization to a specific context, and (3) proper usage of the reused artifact. The approach is supported by a conceptual model which introduces the required concepts to implement COLD. We also present concrete examples of some language concerns and the current state of their realization with metamodel-based and grammar-based language workbenches. We expect this work to provide insights into how to foster reuse in language specification and implementation, and how to support it in language workbenches.}, note = {} } @INPROCEEDINGS{Cazzola19, author = {Kühn, Thomas and Cazzola, Walter and Pirritano Giampietro, Nicola and Poggi, Massimiliano}, title = {{Piggyback IDE Support for Language Product Lines}}, booktitle = {{Proceedings of the 23rd International Software Product Line Conference (SPLC'19)}}, year = 2019, editor = {Thüm, Thomas and Duchien, Laurence}, pages = {}, address = {Paris, France}, organization = {}, publisher = {ACM}, volume = {}, number = {}, series = {}, month = sep, pubtype = {conference}, url = {}, keywords = {lpl dsl sw-engineering}, abstract = {}, note = {} } @INPROCEEDINGS{Cazzola20, author = {Favalli, Luca and Kühn, Thomas and Cazzola, Walter}, title = {{Neverlang and FeatureIDE Just Married: Integrated Language Product Line Development Environment}}, booktitle = {{Proceedings of the 24th International Software Product Line Conference (SPLC'20)}}, year = 2020, editor = {Collet, Philippe and Nadi, Sarah}, pages = {}, address = {Montr\'eal, Canada}, organization = {}, publisher = {ACM}, volume = {}, number = {}, series = {}, month = oct, pubtype = {conference}, url = {}, keywords = {lpl dsl}, abstract = {}, note = {} } @ARTICLE{Cazzola21, author = {Cazzola, Walter and Ghosh, Sudipto and Al-Refai, Mohammed and Maurina, Gabriele}, title = {{Bridging the Model-to-Code Abstraction Gap with Fuzzy Logic in Model-Based Regression Test Selection}}, journal = {{Software and Systems Modeling}}, publisher = {Springer}, year = 2021, volume = 21, number = {}, pages = {207--224}, month = jul, pubtype = {journal}, url = {https://link.springer.com/content/pdf/10.1007/s10270-021-00899-6.pdf}, new = {}, keywords = {testing evolution sw-engineering}, abstract = {Regression test selection (RTS) approaches reduce the cost of regression testing of evolving software systems. Existing RTS approaches based on UML models use behavioral diagrams or a combination of structural and behavioral diagrams. However, in practice, behavioral diagrams are incomplete or not used. In previous work, we proposed a fuzzy logic based RTS approach called FLiRTS that uses UML sequence and activity diagrams. In this work, we introduce FLiRTS 2, which drops the need for behavioral diagrams and relies on system models that \textbf{only} use UML class diagrams, which are the most widely used UML diagrams in practice. FLiRTS 2 addresses the unavailability of behavioral diagrams by classifying test cases using fuzzy logic after analyzing the information commonly provided in class diagrams. We evaluated FLiRTS 2 on UML class diagrams extracted from 3331 revisions of 13 open source software systems, and compared the results with those of code-based dynamic (Ekstazi) and static (STARTS) RTS approaches. The average test suite reduction using FLiRTS 2 was 82.06%. The average safety violations of FLiRTS 2 with respect to Ekstazi and STARTS were 18.88% and 16.53% respectively. FLiRTS 2 selected on average about 82% of the test cases that were selected by Ekstazi and STARTS. The average precision violations of FLiRTS 2 with respect to Ekstazi and STARTS were 13.27% and 9.01% respectively. The average mutation score of the full test suites was 18.90%; the standard deviation of the reduced test suites from the average deviation of the mutation score for each subject was 1.78% for FLiRTS 2, 1.11% for Ekstazi, and 1.43% for STARTS. Our experiment demonstrated that the performance of FLiRTS 2 is close to the state-of-art tools for code-based RTS but requires less information and performs the selection in less time.}, doi = {10.1007/s10270-021-00899-6}, note = {} } @ARTICLE{Cazzola21b, author = {Cazzola, Walter and Favalli, Luca}, title = {{Towards a Recipe for Language Decomposition: Quality Assessment of Language Product Lines}}, journal = {{Empirical Software Engineering}}, publisher = {Springer}, year = 2022, volume = 27, number = {}, pages = {}, month = apr, pubtype = {journal}, url = {https://trebuchet.public.springernature.app/get_content/a573ab10-aec4-46dd-a4ba-77ce4a663722}, new = {}, keywords = {lpl dsl metrics}, abstract = {Programming languages are complex systems that are usually implemented as monolithic interpreters and compilers. In recent years, researchers and practitioners gained interest in product line engineering to improve the reusability of language assets and the management of variability-rich systems, introducing the notions of language workbenches and language product lines (LPLs). Nonetheless, language development remains a complex activity and design or implementation flaws can easily waste the efforts of decomposing a language specification into language features. Poorly designed language decompositions result in high inter-dependent components, reducing the variability space of the LPL system and its maintainability. One should detect and fix the design flaws posthaste to prevent these risks while minimizing the development overhead. Therefore, various aspects of the quality of a language decomposition should be quantitatively measurable through adequate metrics. The evaluation, analysis and feedback of these measures should be a primary part of the engineering process of a LPL. In this paper, we present an exploratory study trying to capture these aspects by introducing a design methodology for LPLs; we define the properties of a good language decomposition and adapt a set of metrics from the literature to the framework of language workbenches. Moreover, we leverage the AiDE 2 LPL engineering environment to perform an empirical evaluation of 26 Neverlang-based LPLs based on this design methodology. Our contributions form the foundations of a design methodology for Neverlang-based LPLs. This methodology is comprised of four different elements: i) an engineering process that defines the order in which decisions are made, ii) an integrated development environment for LPL designers and iii) some best practices in the design of well-structured language decomposition when using Neverlang, supported by iv) a variety of LPL metrics that can be used to detect errors in design decisions.}, doi = {10.1007/s10664-021-10074-6}, note = {} } @ARTICLE{Cazzola22, author = {Bertolotti, Francesco and Cazzola, Walter}, title = {{Fold2Vec: Towards a Statement Based Representation of Code for Code Comprehension}}, journal = {{Transaction on Software Engineering and Methodology}}, publisher = {ACM}, year = 2022, volume = {}, number = {}, pages = {}, month = jan, pubtype = {journal}, url = {https://dl.acm.org/doi/pdf/10.1145/3514232}, new = {}, keywords = {ml}, abstract = {We introduce a novel approach to source code representation to be used in combination with neural networks. Such a representation is designed to permit the production of a continuous vector for each code statement. In particular, we present how the representation is produced in the case of Java source code. We test our representation for three tasks: code summarization, statement separation, and code search. We compare with the state-of-the-art non-autoregressive and end-to-end models for these tasks. We conclude that all tasks benefit from the proposed representation to boost their performance in terms of f1-score, accuracy, and MRR, respectively. Moreover, we show how models trained on code summarization and models trained on statement separation can be combined to address methods with tangled responsibilities. Meaning that these models can be used to detect code misconduct.}, doi = {10.1145/3514232}, note = {} }