G. Cugola and E. Di Nitto. ``Using a Publish/Subscribe Middleware to Support Mobile Computing''. In Proceedings of the Workshop on Middleware for Mobile Computing, in association with IFIP/ACM Middleware 2001 Conference, Heidelberg, Germany, November 2001.
In this paper we argue that the publish/subscribe model is well suited to address the requirements of mobile computing. Unfortunately, current middleware infrastructures implementing such model present some limitation mainly due to the fact that do not account for the possibility of dynamically reconfiguring the system. In this paper we briefly present an approach to partially overcome such limitations and identify some open issues.
G. Cugola, E. Di Nitto, and A. Fuggetta, `` The JEDI event-based infrastructure and its application to the development of the OPSS WFMS''. In Transaction of Software Engineering (TSE), vol. 27, num. 9, September 2001.
The development of complex distributed systems demands for the creation of suitable architectural styles (or paradigms) and related run-time infrastructures. An emerging style that is receiving increasing attention is based on the notion of event. In an event-based architecture, distributed software components interact by generating and consuming events, an anonymous and asynchronous form of messages. The occurrence of an event in a component is asynchronously notified to any other component that has declared some interest in it. This paradigm holds the promise of supporting a flexible and effective interaction among highly reconfigurable, distributed software components. In the past two years, we have developed an object-oriented infrastructure called JEDI (Java Eventbased Distributed Infrastructure). JEDI supports the development and operation of event-based systems and has been used to implement a significant example of distributed system, namely, the OPSS workflow management system (WFMS). The paper illustrates JEDI main features and how we have used them to implement OPSS. Moreover, the paper provides an initial evaluation of our experiences in using the event-based architectural style.
Gerald Reif, Engin Kirda, Harald Gall, Gian Pietro Picco, Gianpaolo Cugola, and Pascal Fenkam ``A Web-based peer-to-peer architecture for collaborative nomadic working''. In Proceedings of the 3rd International Workshop on Web-based Infrastructures and Coordination Architectures for Collaborative Enterprises, co-located with the 10th International Workshops on Enabling Technologies: Infrastructure for Collaborative Enterprises (WETICE 2001), MIT, Cambridge (MA, USA), June 2001.
With the recent advances in mobile computing, distributed organizations are facing a growing need for advanced Information and Communication Technologies (ICT) that support mobile working. The ability to use information effectively anywhere and anytime has become a key business success factor. Although many Computer Supported Collaborative Work (CSCW) systems have been introduced to date, technologies and architectures that support the collaboration of nomadic workers on a wide range of mobile devices, notebooks and personal computers is still a challenge. The MObile Teamwork Infrastructure for Organizations Networking (MOTION) project is aiming to design a highly flexible, open and scalable ICT architecture for mobile collaboration. In this paper, we present the mobile collaboration requirements of two MOTION industry case studies, and highlight the advantages of a Web-based peer-to-peer architecture and for nomadic working.
F. Casati and G. Cugola, ``Error Handling in Process Support Systems''. In Advances in Exception Handling Techniques. A. Romanovsky, C. Dony, J.L. Knudsen, A. Tripathi (Eds), LNCS Vol. 2022, Springer-Verlag, 2001.
Process Support Systems (PSSs) are software systems supporting the modeling, enactment, monitoring, and analysis of business processes. Process automation technology can be fully exploited when predictable and repetitive processes are executed. Unfortunately, many processes are faced with the need of managing exceptional situations that may occur during their execution, and possibly even more exceptions and failures can occur when the process execution is supported by a PSS. Exceptional situations may be caused by system (hardware or software) failures, or may by related to the semantics of the business process.
In this paper we introduce a taxonomy of failures and exceptions and discuss the effect that they can have on a PSS and on its ability to support business processes. Then, we present the main approaches that commercial PSSs and research prototypes offer in order to capture and react to exceptional situations, and we show which classes of failure or exception can be managed by each approach.
G. Cugola, C. Ghezzi, and M. Monga,``Malaj: A Proposal to Eliminate Clashes Between Aspect-Oriented and Object-Oriented Programming''. In Proceeding of 16th IFIP World Computer Congress, International Conference on Software: Theory and Practice (WCC2000), Beijing (China), August 21-25, 2000.
Aspect-oriented programming (AOP) aims at providing linguistic mechanisms that enable better separation of concerns in program development. Mainstream techniques, like object-oriented programming, do not provide a satisfactory solution to this problem, in that they do not capture the frequent case of aspects that cross-cut system components, and hence cannot be fully encapsulated. On the other hand, AOP is in its early stages, and it is still unclear what are the fundamental design criteria for aspect-oriented languages (AOLs). A previous evaluation of a general-purpose AOL suggested that the flexibility gained by the ability to freely intertwine aspect and functional code opens several potential conflicts with the principles of objectorientation. Based on this experience, in this paper we present an alternative approach where the vision of a general-purpose AOL is replaced by the vision of a system where several, independent aspects are gathered, each providing specialized support for a single concern. The hypothesis underlying this work is that such a design approach provides a good compromise between flexibility and preservation of good object-oriented and programming principles.
G. Cugola, P.Y. Cunin, S. Dami, J. Estublier, A. Fuggetta, F. Pacull, M. Riviere, and H. Verjus, ``Customizing the behavior of middleware: the PIE approach'' in proceeding of the Workshop on Reflective Middleware (RM2000), New York (USA), April 7-8, 2000.
No abstract available. Click on the title above to download a copy of the paper
G. Cugola, P.Y. Cunin, S. Dami, J. Estublier, A. Fuggetta, F. Pacull, M. Riviere, and H. Verjus, ``Support for Software Federations: the PIE Platform''in proceeding of the Seventh European Workshop on Software Process Technology, Kaprun near Salzburg, Austria, February 22-25, 2000.
No abstract available. Click on the title above to download a copy of the paper
G. Cugola, C. Ghezzi, and M. Monga,``Coding Different Design Paradigms for Distributed Applications with Aspect-Oriented Programming''in proceeding of WSDAAL99, L'Aquila (Italy), September 13-15, 1999.
In this paper we discuss how Aspect-Oriented Programming (AOP) may be useful in the design of distributed applications. Different design paradigms might be singled out in separate aspects, thus separating the "functional" code of an application from the interchangeable parts describing the distribution.
After introducing an Aspect-Oriented Language (AspectJ), we illustrate its use in a simple toy example. This will allow us to identify how research should progress to make AOP a useful approach in the design of a distributed application
G. Cugola, C. Ghezzi, and M. Monga,``Language Support for Evolvable Software: An Initial Assessment of Aspect-Oriented Programming''in proceeding of the International Workshop on Principles of Software Evolution, Fukuoka (Japan), July 16-17, 1999.
No abstract available. Click on the title above to download a copy of the paper
G. Cugola and C. Ghezzi, ``Design and Implementation of PROSYT: a distributed Process Support System''. in Proceeding of the Eighth International Workshop on Enabling Technologies: Infrastructures for Collaborative Enterprises, Stanford (CA), June 16-18, 1999.
This paper describes the design and implementation of a process support system (PROSYT), which is intended to provide guidance in performing business processes and cooperation among people over a local or geographically distributed architecture. Our main purpose here is to understand how complex applications of this kind can be developed systematically. In particular, how the requirements of high flexibility, reconfigurability, scalability, and efficiency demanded by these applications can be met through appropriate design paradigms.
The conventional client-server design paradigm, which is normally used for distributed applications, does not match the previous requirements. We decided to base the design and implementation of PROSYT on (1) an event-based framework for the integration and cooperation of components and (2) the use of mobile agents. Thus components cooperate by sending and receiving events and can migrate from host to host in a local or wide area network.
Event-based integration frameworks and mobile agents are rather novel techniques, and little experience has been reported on their use. Moreover, so far they have been used in simple applications, and we are not aware of designs where they have been used in combination. This paper discusses why these techniques were useful in implementing the PROSYT system and why they would be useful in implementing similar cases of distributed cooperative process infrastructures.
G. Cugola, `` Tolerating Deviations in Process Support Systems Via Flexible Enactment of Process Models''. In Transactions on Software Engineering (TSE), vol. 24, num. 11, November 1998.
Process Support Systems (PSSs) support business organizations in modeling, improving, and automating their business process. Thanks to their ability in enacting process models, they can be used to guide people in performing their daily work and to automate the repetitive tasks that do not require human intervention. Given these potential benefits, it is surprising to observe that PSSs are rarely adopted, even in mature business organizations. This fact can be explained by observing that currently available PSSs do not fulfill the needs of modern business organizations. One of the major problems they present is that they do not offer the right mechanisms to cope with unforeseen situations. They are good in supporting business processes if all proceeds as expected, but if an unexpected situation is encountered, which requires a deviation from the process model to be solved, they often become more an obstacle than a help.
This paper analyzes the problem of managing unforeseen situations that require deviations from the process model during enactment and describes PROSYT, a PSS featuring a novel approach to process model enactment. During process model enactment, PROSYT is capable of tolerating deviations from the process model by supporting users even when unexpected situations arise. It controls that nothing bad could happen and supports users in reconciling the process model with the process actually followed, if necessary.
G. Cugola and C. Ghezzi, ``Software Processes: a Retrospective and a Path to the Future''. In Software Process Improvement and Practice (SPIP), vol. 4, num. 3, September 1998.
Software engineering focuses on producing quality software products through quality processes. The attention to processes dates back to the early 70's, when software engineers realized that the desired qualities (such as reliability, efficiency, evolvability, ease of use, etc.) could only be injected in the products by following a disciplined flow of activities. Such a discipline would also make the production process more predictable and economical. Most of the software process work, however, remained in an informal stage until the late 80's. From then on, the software process was recognized by researchers as a specific subject that deserved special attention and dedicated scientific investigation, the goal being to understand its foundations, develop useful models, identify methods, provide tool support, and help manage its progress.
This paper will try to characterize the main approaches to software processes that were followed historically by software engineering, to identify the strengths and weaknesses, the motivations and the misconceptions that lead to the continuous evolution of the field. This will lead us to an understanding of where we are now and will be the basis for a discussion of a research agenda for the future.
G. Cugola, E. Di Nitto, and A. Fuggetta, `` Exploiting an event-based infrastructure to develop complex distributed systems'' in Proceedings of the 20th International Conference On Software Engineering (ICSE98), Kyoto, Japan, April 1998.
The development of complex distributed systems demands for the creation of suitable architectural styles (or paradigms) and related run-time infrastructures. An emerging style that is receiving increasing attention is based on the notion of event. In an event-based architecture, distributed software components interact by generating and consuming events. The occurrence of an event in a component (called source) is asynchronously notified to any other component (called re-cipient) that has declared some interest in it. This paradigm holds the promise of supporting a flexible and effective in-teraction among highly reconfigurable distributed software components.
We have developed an object-oriented infrastructure, called JEDI (Java Event-based Distributed Infrastructure), to sup-port the development and operation of event-based systems. During the past year, JEDI has been used to implement a significant example of distributed system, namely, the OPSS workflow management system.
The paper illustrates JEDI main features and how we have used it to implement the OPSS workflow management sys-tem. Moreover, it provides an initial evaluation of our expe-riences in using an event-based architectural style.
G. Cugola, P. Fusaro, A. Fuggetta, L. Lavazza, S. Manca, M. R. Pagone, G. Ruhe, and R. Soro, ``A Case Study of Evaluating Configuration Management Practices with Goal-Oriented Measurement'' in Proceedings of the 4th International Symposium on Software Metrics (Metrics '97), Albuquerque, New Mexico (U.S.A.), November 1997.
The paper describes the application of goal-oriented measurement for evaluating configuration management prac-tices at Societ` Interbancaria per l'Automazione (SIA). SIA is in charge of running, developing, and maintaining the Na-tional Interbank Network of Italy. The results of a CMM-based process assessment [15] indicated that Configuration Management (CM) practice was one of the most promising areas for improvement. A project was initiated aimed at es-tablishing an improved CM process supported by state-of-the-art tools and incorporating sound practices [6,11]. It was decided to apply the new process to one of the most impor-tant products of SIA, which deals with the development of a new generation of networking software. Goal-oriented meas-urement following the Goal/Question/Metric (GQM) ap-proach was applied to monitor the establishment of the CM process. The paper describes the establishment and execution of the measurement program and reports about related prod-uct and process modeling. Different techniques for qualita-tive and quantitative analysis of experimental data were per-formed. Selected results and experiences are reported.
G. Cugola and C. Ghezzi, ``CJava: Introducing Concurrent Objects in Java'' in Proceedings of the 4th International Conference on Object-Oriented Information Systems (OOIS '97), Brisbane (Australia), 10-12 November 1997.
Java is rapidly becoming one of the most popular object-oriented languages. It is portable and architecture neutral, it is easy to use, it is designed to support the development of highly reliable and robust applications, it is dynamic. But it is not truly concurrent. Indeed, Java supports a limited form of concurrency through a class Thread, provided as part of the Java standard library. Concurrency features, however, do not integrate nicely with the object-oriented paradigm. Java programmers are required to take care of many details to develop concurrent applications. In this paper, we describe the language CJava, an extension of Java featuring concurrent objects. We also discuss how CJava can be mapped into Java.
G. Cugola, L. Lavazza, V. Nart, S. Manca, and M. R. Pagone, ``An Experience in Setting-Up a Configuration Management Environment'' in Proceedings of the 8th International Workshop on Software Technology and Engineering Practice (STEP '97), London, July 1997.
Configuration management (CM) is widely recognized as one of the most important practices that have to be established for developing software in an ordered and controlled way. Despite this, the process of setting-up CM has obtained till now very little attention. This paper reports the lessons learned in establishing CM at SIA (Societ` Interbancaria per l'Automazione), the organization in charge of running, developing, and maintaining the National Inter-bank Network of Italy.
G. Cugola and C. Ghezzi, `` Inconsistencies in software development: Towards a reference framework'' in Prooceedings of the ICSE'97 WorkShop on "Living with Inconsistencies", Boston, MA, May 1997.
This paper describes a framework to formalize the concept of inconsistency in software development. This framework will be used to analyze and compare several approaches proposed in literature to deal with the different forms of inconsistencies that may arise in software development.
G. Cugola, C. Ghezzi, G.P. Picco G. Vigna, `` Analyzing Mobile Code Languages'' in Mobile Object Systems: Towards the Programmable Internet, Springer-Verlag, LNCS State-of-the-Art Survey, April 1997.
The growing importance of telecommunication networks has stimulated research on a new generation of programming languages. Such languages view the network and its resources as a global environment in which computations take place. In particular, they support the notion of code mobility. To understand, discuss, evaluate, and compare such languages, it is necessary to develop a new set of programming language concepts and/or extend the concepts that are used to deal with conventional languages. The purpose of this paper is to provide such framework. This is done hand-in-hand with a survey of a number of existing new languages.
G. Cugola, E. Di Nitto, A. Fuggetta, C. Ghezzi,``A Framework for Formalizing Inconsistencies and Deviations in Human-Centered Systems'' in ACM Transactions on Software Engineering and Methodology (TOSEM), vol. 5, num. 3, July 1996.
Most modern business activities are carried out by a combination of computerized tools and human agents. Typical examples are engineering design activities, office procedures, and banking systems. All these human-centered systems are characterized by the interaction among people, and between people and computerized tools. This interaction defines a process, whose effectiveness is essential to ensure the quality of the delivered products and/or services. To support these systems, process-centered environments and workflow management systems have been recently developed. They can be collectively identified with the term process technology. This technology is based on the explicit definition of the process to be followed (the process model). The model specifies the kind of support that has to be provided to human agents.
An essential property that process technology must exhibit is the ability of tolerating, controlling, and supporting deviations and inconsistencies of the real world behaviors with respect to the process model. This is necessary to provide consistent and effective support to the human-centered system, still maintaining a high degree of flexibility and adaptability to the evolving needs, preferences, and expertise of the human agents.
This paper presents a formal framework to characterize the interaction between a human-centered system and its automated support. It does not aim at introducing a new language or system to describe processes. Rather, it aims at identifying the basic properties and features that make it possible to formally define the concepts of inconsistency and deviation. This formal framework can then be used to compare existing solutions and guide future research work. Finally, we argue that our approach provides a general and reference framework to characterize the interaction between a computerized system and the (parts of) the real world it is supposed to describe and possibly control.
G. Cugola, C. Ghezzi, G.P. Picco G. Vigna, ``A Characterization of Mobility and State Distribution in Mobile Code Languages'' in Proceedings of the 2nd ECOOP Workshop on Mobile Objects, 8-9 July 1996, Linz, Austria.
No abstract available. Click on the title above to download a copy of the paper
G. Cugola, E. Di Nitto, C. Ghezzi, M. Mantione, ``How to deal with deviations during process model enactment'', in Proceedings of 17th International Conference on Software Engineering (ICSE17), Seattle, Washington USA, April 1995.
A fundamental problem in software processes is how the intrinsic rigidity of a predefined (formal) model can be reconciled with the need for flexibility, change, and evolution. We therefore distinguish between software processes, as specified in a process description, and their actual performance by humans. Further, we claim that the two inevitably diverge, and thus it is necessary to provide means to reconcile them. We present a preliminary exploration into the problem. In particular, we illustrate how a temporal logic-based approach can be used to capture and tolerate some deviations from the process description during execution. We present a simple process language (LATIN), and its prototype environment (SENTINEL), in which these ideas are currently experimented.
G. Cugola, ``CJava: a Proposal to Circumvent the Inheritance Anomaly in True Concurrent Object-Oriented Languages''. Technical Report 97.42, Dipartimento di Elettronica e Informazione - Politecnico di Milano, 1997.
In order to combine concurrency with object orientation and reuse, the so-called "inheritance anomaly" has to be faced and solved. A large number of solutions have been proposed in the literature to solve the inheritance anomaly in the contest of quasi-concurrent object-oriented languages (i.e., concurrent object-oriented languages where only one activity at a time is allowed to execute in each object). In this paper we survey such proposals and describe a solution to the problem of inheritance anomaly in true concurrent OO languages (i.e., languages where more than one activity at a time are allowed to execute in each object) by presenting the language CJava, an extension to Java featuring true concurrent objects. We also discuss how CJava can be mapped into Java.
G. Cugola, ``A Logical Theory of Static Reasoning for Rational Agents'', Technical Report 09-96, Politecnico di Milano, Piazza Leonardo da Vinci 32, I-20133 Milano, Italy, February 1996.
A formal language to describe mental states of rational agents is useful to specify the behavior of artificial agents that are supposed to act intelligently and to help human beings in evaluating their reasoning about the external environment.
This paper presents a multi-agent, propositional, temporal logic to describe the mental state of rational agents. The formal properties of beliefs and intentions of rational agents and the relationships between such mental attitudes are first informally sketched. Then, a logical language whose semantics captures these properties and relationships is presented. In particular, this logic provides two modal operators to describe rational agents' beliefs and intentions at each time instant. The above-mentioned properties of beliefs and intentions are formalized as logical axioms.
G. Cugola, `` Inconsistencies and Deviations in Process Support Systems''. Politecnico di Milano, February 1998.