ECLIPSE IT The 6th Workshop of the Italian Eclipse Community. Proceedings of the Workshop

Transcription

1

2 ECLIPSE IT 2011 The 6th Workshop of the Italian Eclipse Community Proceedings of the Workshop Francesca Arcelli Leonardo Mariani and Domenico Squillace September 22th and September 23th, 2011 University of Milano Bicocca, Italy

3 Edited by Prof. Francesca Arcelli Università di Milano Bicocca, Italy Copyright 2011 by the Italian Eclipse Community. All Right Reserved. ISBN:

4 Committees Workshop Chair Francesca Arcelli University of Milano Bicocca, Italy Workshop Co-Chair Paolo Maresca Mauro Coccoli University of Napoli Federico II, Italy University of Genova, Italy Technical track Chair Francesca Arcelli University of Milano Bicocca, Italy Student track Chair Leonardo Mariani University of Milano Bicocca, Italy Industry track Chair Domenico Squillace IBM, Italy Organizing Committee Francesca Arcelli Leonardo Mariani Oliviero Riganelli University of Milano Bicocca, Italy University of Milano Bicocca, Italy University of Milano Bicocca, Italy

5 Program Committee Giovanni Adorni Marco Aimar Francesca Arcelli Luciano Baresi Francesco Bergdano Walter Binder Marco Brambilla Fabio Calefato Mauro Coccoli Andrea De Lucia Francesco di Cerbo Giovanni Denaro Claudio Ferretti Giacomo Franco Rosario Gangemi Angelo Gargantini Ferdinando Gorga Filippo Lanubile Paolo Maresca Leonardo Mariani Carla Milani Mattia Monga Antonio Natali Enrico Oliva Fabrizio Perin Claudia Raibulet Elvinia Riccobene Oliviero Riganelli Domenico Squillace Patrizia Scandurra Vittorio Scarano Carmine Seraponte Domenico Squillace Lidia Stanganelli Marco Torchiano Rodolfo Totaro Gianni Vercelli Marco Zanoni University of Genova, Italy Opera21, Italy University of Milano Bicocca, Italy Politecnico di Milano, Italy Univerity of Torino, Italy University of Lugano, Switzerland Politecnico di Milano, Italy University of Bari, Italy University of Genova, Italy University of Salerno, Italy University of Trento, Italy University of Milano Bicocca, Italy University of Milano Bicocca, Italy IBM, Italy IBM, Italy University of Bergamo, Italy IBM, Italy University of Bari, Italy University of Napoli Federico II, Italy University of Milano Bicocca, Italy IBM, Italy University of Milano, Italy University of Bologna, Italy S.E.I.C. s.r.l., Italy University of Bern, Switzerland University of Milano Bicocca, Italy University of Milano, Italy University of Milano Bicocca, Italy IBM, Italy University of Bergamo, Italy University of Salerno, Italy Opera21, Italy IBM, Italy University of Genova, Italy Politecnico di Torino, Italy Energeya Italia, Italy University of Genova, Italy University of Milano Bicocca, Italy iv

6 Sponsors of Eclipse-IT 2011 v

7 Contents Keynotes Eclipse an Open Source Innovation Network for the Industries.1 (Ralph Müller) Framework rich client application..2 (Paolo Giardiello) An outlook and trend in software industry market: Software Factory and best practices in successful enterprise software delivery..3 (Giorgio Galli) Technical Track Software Engineering, Reverse Engineering and Services Model-driven communications and collaborative software development.4 (Antonio Natali) Enabling End-User Plug-in Compositions with MASH..16 (Leonardo Mariani, Fabrizio Pastore) Reverse engineering Java Enterprise Applications in Eclipse.28 (Raphael Krebs, Fabrizio Perin) An Eclipse Plug-in for the Identification of Design Pattern Variants..40 (Andrea De Lucia, Vincenzo Deufemia, Carmine Gravino, Michele Risi, Genoveffa Tortora) An Eclipse-based SCA design framework to support coordinated execution of services.52 (Fabio Albani, Elvinia Riccobene, Patrizia Scandurra) An Eclipse Plug-in for Engineering Service Interchangeability..64 (Giovanni Denaro, Davide Tosi) Testing and Security The AutoBlackTest Tool: Automating System Testing of GUI-based Applications...78 (Leonardo Mariani, Oliviero Riganelli, Mauro Santoro) vi

8 TestCareAssistant: Automatic Repair of Test Case Compilation Errors 90 (Mehdi Mirzaaghaei, Fabrizio Pastore) An eclipse-based environment for conformance testing by FSMs (Angelo Gargantini, Marco Guarnieri, Eros Magri) An Eclipse plug-in for Test-to-Code Traceability Recovery (Abdallah Qusef, Gabriele Bavota, Rocco Oliveto, Andrea De Lucia, David Binkley) An Eclipse plug-in for specifying security policies in modern information systems (Simone Mutti, Mario Arrigoni Neri, Stefano Paraboschi) Security vulnerabilities detection and protection using Eclipse. 138 (Marco Guarnieri, Paul El Khoury, Gabriel Serme) Learning and Agents Persistence of the Memory: an introduction to the asset and intellectual capital management Application into the ETC project.150 (Ferdinando Gorga, Paolo Maresca) Knowledge sharing and cooperation among communities of practices: a possible scenario? (Giacomo Franco, Paolo Maresca, Giancarlo Nota, Marialuisa Saviano) Towards cloud learning with ETC and Juzzhub (Paolo Maresca, Carla Milani, Ferdinando Gorga, Giorgio Galli) Learning Processes and Cooperative Development in Software Engineering (Mauro Coccoli, Paolo Maresca, Lidia Stanganelli) Agent-Based Business Process Management with Eclipse 205 (Federico Bergenti, Giovanni Caire, Danilo Gotta, Elena Quarantotto, Giovanna Sacchi) Exploiting the Eclipse Ecosystem for Agent-Oriented Programming (Alessandro Ricci, Andrea Santi, Andrea Leardini, Antonio Natali) Applications and Tools An Eclipse Plug-in to Model System Requirements and Adaptation Capabilities (Luciano Baresi, Liliana Pasquale) An eclipse-based feature diagrams toolchain.242 (Luca Gherardi, Davide Brugali) vii

9 CViewer: an application for path routing analysis in a Telco software solution and the eclipse framework..254 (Loredana Luzzi, Alessandro Niglio, Marianna Peluso, Dario Pesole, Andrea Piccolo, Carmine Seraponte) An Eclipse plug-in for Public Administration software system modelling and simulation (Damiano Falcioni, Alberto Polzonetti, Andrea Polini, Barbara Re, Riccardo Cognini) PrEdE: a Projectional Editor for the Eclipse Modeling Framework..278 (Federico Tomasetti, Marco Torchiano) Students Track Combining SysML modelling with refinement checking in Eclipse.290 (Riccardo Sisto, Denis Makartetskiy) Managing On The Road Eclipse (OTRE) project, using the RTC Tools (Antonio Luparelli, Lidia Stanganelli) On The Road Eclipse: Single Sign In Project 299 (Fabrizio Ruocco, Gaetano Prisco, Antonio Luparelli) R -Blending Talk and Work in Eclipse. 303 (Alberto Bacchelli, Lorenzo Baracchi, Michele Lanza) Manhattan -3D City Visualizations in Eclipse (Alberto Bacchelli, Francesco Rigotti, Lile Hattori, Michele Lanza) AsmetaRE: an Eclipse-based Environment for Requirements Validation via Use Case Models and Abstract State Machines (Marco Dolci, Andrea Arnoldi) A DSL to define process templates in Jazz/RTC (Sam Golovchenko, Luca Pandolfo) A simple plugin for static security checks and program comprehension in Eclipse..319 (Andrea La Scola, Claudio Ferretti) Public Institutions and Industry Track Building a JEE application with Eclipse 322 (Marco De Luca, Giampiero Restaino) Extending the BPEL Designer with Xtext based editors (Lorenzo Bettini, Vincenzo Caselli, Francesco Guidieri) viii

10 Rational Quality Manager and Rational Team Concert adoption in Tivoli Rom Lab..334 (Ilaria Gorga, Alessandro De Micco) Parasoft Test: Complete Development Lifecycle Testing (Daniele Marsico, Clémence Soulat) ix

11 Eclipse - an Open Source Innovation Network for the Industries Ralph Müller Director Eco Systems Europe of the Eclipse Foundation Abstract. Open Source- for many the expression is a synonym for no cost or easy to obtain. Only known to the insider is the fact that Open Source methods and licenses have become the basis of many industry collaboration efforts. Here Open Source is applied to jointly develop, maintain and distribute software relevant for the industry. Due to its well-defined Intellectual Property Management and its Development Process is the Eclipse Project today well positioned to support industry initiatives in the collaborative value creation process. The commerce-friendly Eclipse Public License (EPL) makes it easy to capture value in commercial exploitation, providing the basis for a successful and sustainable eco system. While collaboration in the past was mostly organized by software vendors, we now experience that corporate software consumers are organizing their own consortia to work together on creation of relevant software. Based on Airbus TOPCASED and OPEES projects we will discuss the needs of these consortia and how organizations such as the Eclipse Foundation can provide an organizational framework to support these efforts. 1

12 Framework rich client application Paolo Giardiello SOGEI, Head of the Application Architectures Department Abstract. Every year Sogei distributes Java-based, standalone applications to the Italian citizens and to professional users. To achieve the goal of increased efficiency and improved quality of service, a project is underway to create a RCA framework promoting the creation of Eclipse RCP-based applications, while introducing in our company innovative solutions available in the open source community. The technological features that we are implementing in the framework are as follows: All applications plug into a Unified Desktop Application of the Workspace concept for user s data management using EFS (Eclipse File System) Custom software migration to OSGi technology and future use of these modules within JavaEE Application Server Application log based on the Pax Logging framework Help system based on the DocBook framework Software Upgrade via P2 and multi-site management Eclipse RCP Security Local Authentication Remote Authentication Profiling applications UI look and feel via CSS Data Binding and Validation via EMF User Interface Proprietary Language for UI definition; it will migrate to XText in future releases Swing integration into Eclipse view XMLSWT The framework is not limited to the client, standalone components, but is to be completed by a number of services, enabling remote access to our datacenter infrastructure offering data persistence, authentication/authorization and more, thus allowing fine-grained control from a central location. The technology chosen for this project is Eclipse, and we opted to reuse existing components to minimize changes on consolidated libraries. A series of infrastructure components has also been developed to: Establish a standard method for client applications to use the services Rationalize the services Reduce the impact on the infrastructure Open client applications to innovative technologies 2

13 An outlook and trend in software industry market: Software Factory and best practices in successful enterprise software delivery Giorgio Galli IBM Technical Leader Rational Software, South West Europe Abstract. Company and market that rely on software is growing faster. This is because software became more and more pervasive in our life. Software is flexible. Business process and people directly on indirectly run on it. Today software failure has tremendous impact and can cause several of millions of losses to organizations. In this context software delivery organization are under pressure to produce more software, faster, and with extreme cost pressure and increased quality. We will explore the concept of a Software Factory and which best practices have demonstrated how help organizations to decide what to invest in, develop what they decided, and deploy what they developed. 3

14 Model-driven communications and collaborative software development Antonio Natali Alma Mater Studiorum Università di Bologna Abstract Custom languages inherently associated via meta-modeling with the concrete organization of software systems, can promote not only better products, but can also allow people to efficiently describe and understand their collaboration, by identifying relevant relationships among tasks, developers and artifacts within a particular work context. This paper makes reference to Contact [1], a language usable as a meta-model for high-level communications within distributed systems, to show how it can promote structured forms of collaborations between workers with different skills and scope (e.g. customers, application designers and system designers), by providing at the same time other important benefits typical of the Model Driven Software Development (MDSD) approach [2]: i) the formal definition of a conceptual space useful in all the phases of software development; ii) the possibility to build a custom software factory that explicitly represents and spread the know-how of a company; iii) the automated construction of infrastructures tailored to application needs; iv) the usage of models as a new form of source code that can allow application designers to write platform-independent code. Keywords: Cooperative work, Meta-modeling, Communication, Software Factory, Eclipse, XText. 1 Introduction Software applications become increasingly heterogeneous and distributed and communication takes an increasingly central role in modern - service-oriented - software systems. Communication is commonly defined as the interchange of thoughts, opinions, or information by speech, writing, or signs. The problem is that current programming languages do not provide adequate expressive power and for many software developers, communication is only the emerging result of activities performed by using some software component providing communication mechanisms. As a consequence, the task of designing and building software components more related to a communication infrastructure rather than to the business logic is often repeated several times, each time in a different way. Worst, the analyst and the designer have no reference language to build a logic architecture of the system, with the intent to talk with customers at their abstraction level and to summarize information useful to evaluate the risks and to define well-founded plans for software development. 4

15 Thanks to Eclipse-based technologies, appropriate application-oriented conceptual spaces can be defined as meta-models introduced as custom domain specific languages (DSL). According to the MDSD[2] approach, model-to-model (M2M) and model-to-code (M2C) transformers can provide a custom Software Factory able to reduce the gap between models and code and to produce in automatic way the intrinsic systematic of an infrastructure as part of an user-defined design. MDSD promotes also the possibility to organize in a structured and unambiguous way the cooperation among the workers of a team. In fact, people working on the application logic (called from now on application designers) can define in a formal way new abstractions peculiar to the application domain. On the other hand, the team members more involved into the technical details of a infrastructure (called from now on system designers) can produce not only new operational platforms tailored to application needs, but also new concepts usable as they were primitive. New primitive concepts, defined by keeping into account specific application problems, are essential to face in an effective way the analysis and the design phase of modern software systems 1. Each software company could define, implement and use its own set of primitive concepts, by providing a custom IDE, based, in its turn, on custom meta-models usable as conventional (domain specific) languages. The activities of a team can be planned around this custom IDE that becomes the main artifact able to explicitly represent and transmit the knowledge and the know-how of the company both in the application domain and in the (relationship with the) supporting technologies. The aim of this work is to discuss these perspectives with reference to Contact [1], a language (a meta-model) that has been defined by exploiting Eclipse, Eclipse EMF[3] and the Xtext2.0[4] framework. The aim of Contact is to help application designers in: i) building models of high-level communication patterns that can be used as a new form of source code; ii) defining in a systematic way related to the definition of the operational semantics of the language the communication infrastructure; and iii) creating the IDE (Contact-ide in the following) that makes the language usable. The work is structured as follows. The Section 2 introduces the Contact meta model and gives an informal overview of its conceptual space, by introducing the primitives that the language provides. The Section 3 discusses the impact of Contact on the production process with reference to an example. The collaboration between application and system designers is discussed in Section 4, with reference to a set of technical and logical problems that can arise when the system must be transformed from a prototype to a true distributed system. This section gives also some detail on how the model-driven approach helps in structuring an application as a layered system in which each layer is associated to a proper meta-model. Finally Section 5 is devoted to the conclusions. 1 Imagine what could be a modern software production process without concepts like loop. collection, socket, object, class, process, agent etc 5

16 2 The Contact meta-model It is quite common to say that, in order to communicate, two software entities should exchange messages. Since sentences such as send a message or receive a message are not well defined, a more appropriate vocabulary for message-based interaction is needed. The main goal of the Contact language is to provide a conceptual space (and an associated vocabulary) to express a basic set of high-level forms of communication. The Contact conceptual space is based on a Message ontology defined in XText 2 (only a subset of the message types is shown): Message: OutOnlyMessage OutInMessage; OutOnlyMessage: Signal Dispatch ; OutInMessage: Request Invitation; OutOnlyMessage: informationthatasubjectsends(tosome other subject) without any expectation to receive a reply related to that message. OutInMessage: information that a subject sends (to some other subject) with the expectation to receive some reply (e.g. an ack, an answer, etc.) related to that message. Each Message type is associated with a pair of high level operations (one to send information and one to receive information) like those written in bold in Table 1, that reports an informal description of the Message semantics 3.The exact semantics of each term of the vocabulary is (operationally) defined by the system designer (see Subsection 4.1), which concurs also to the definition of the language with appropriate feedbacks. MsgType Informal meaning Signal a(outonlymessage) messagethatasubjectcanemit on the sharedspace; asignalcan be sensed by N>=0 time uncoupled subjects. Example: aclickofthemouse(asignalthat can be perceived by a window). Dispatch a(outonlymessage) messagethatasubjectcanforward to one specific receiver-subject, with the expectation that it will serve it. Example: amessagesentbyageneraltohis colonels on the battlefield. Invitation a(outinmessage) messagethatasubjectcanask to ND>=1 receivers, with the expectation to acquire NR>=0 acknowledgments (ack); a receiver will accept an invitation and will reply with an ack to the sender. Example: amessagesentbyagovernmentofacountrytoall its ambassadors in order to do something. Request a(outinmessage) messagethatasubjectcandemand to ND>=1 receivers, with the expectation to acquire NR>=0 responses; a receiver will grant arequestandwillanswer to the sender with a response. Example: amessagesenttoknowsomething. Table 1. Message informal semantics The main idea underlying the Contact conceptual space is that a distributed system is composed of a set of entities, called Subjects 4, each associated with a unique name; the subjects can exchange information via the sharedspace abstraction. The sharedspace defines basic operations to write (out), read (rd,rdw) or consume (in) information defined by an interface named ILindaLike. 2 Thus, each Contact specification is also a model, instance of a meta-model. 3 This vocabulary is open-ended, since it is proposed to capture communication patterns that frequently occur in the application domain. 4 This term has been used to avoid confusion with Object, Process, Agent, etc. 6

17 ILindaLike public interface ILindaLike { public IMessage in(string query) throws Exception; public IMessage rd(int LastMsgNum, String querymsg) throws Exception; public IMessage rdw(int LastMsgNum, String querymsg) throws Exception; public void out( String msg ) throws Exception; public Vector<IMessage> inmany(vector<string> tokens) throws Exception; public IMessage selectonefrommany(int msgnum,vector<imessage> queries) throws Exception; public void terminate() throws Exception; } ILindaLike operations are used as the reference machine to define the operational semantics of Contact (see Subsection 4.1). High-level communication patterns are associated to the Message types and can be expressed by means of a set of HighLevelOperation defined in XText as follows: Concrete syntax(contact) HighLevelOperation: OutOperation InOperation ; OutOperation: emitsignal forwarddispatch demandrequest askinvitation ; InOperation: InAcquireOperation InPerceiveOperation; InAcquireOperation: servedispatch grantrequest acceptinvitation; InPerceiveOperation: sensesignal ; Abstract syntax(medcl) IntermediateOperation: OpIn OpOut; OpIn: OpToPerceiveInfo OpToAcquireInfo OpToAcquireManyInfo ; OpOut: OpToEmitInfo OpToSendToOne OpToSendToMany ; An OutOperation is an instance of OpOut. An InOperation is an instance of OpIn. OpOut: usedtosendinformation. OpIn: usedtoacquireinformation. The definition of the language includes a concrete syntax (the Contact language itself) and an abstract syntax expressed by the intermediate language medcl. High-level operations can be viewed as a set of primitives whose concrete notation is provided by Contact and whose semantics is defined by a run time support built over on a lower-level support that implements the ILindaLike interface according to the meaning given to the medcl meta-model (see Subsection 4.1). The ILindaLike interface can be ignored by the application designer, since the behavior of each Subject is conceived, at application level, as a finite state machine (FSM) whose state transitions are associated to application-specific, generated communication methods, whose structure can be sketched as follows: Output operation scheme <AnswerType> hl_<sendername>_<operationname>_<messageid>_<receivername>(string M){ ILindaLike support = PlatformExpert.findOutSupport(<ReceiverName>,<messageId>,<SenderName>); <AnswerType> answer=<sendername>_<operationname>_<messageid>_<receivername>( M,support ); return answer; } Input operation scheme <ReturnType> hl_<receivername>_<operationname>_<messageid>(){ ILindaLike support = PlatformExpert.findInSupport( <ReceiverName>,<messageId>,<WithAnswer>); <ReturnType> answer=<receivername>_<operationname>_<messageid>( support ); return answer; } 7

18 An application-specific method starts by calling the PlatformExpert object, so to dynamically find (or build) the right communication run-time support (Section 4); then it calls a corresponding low-level operation that defines the operational semantics in terms of ILindaLike operations by giving to it the support to perform the required communication actions. The following table shows the types that can be assumed by the object returned by a Contact operation. AnswerType void: whennoreplyisexpectedbythecaller. IAcquireOneReply: when the caller expects to receive back just one reply. IAcquireManyReply: when the caller expects to receive one or more reply. ReturnType IMessage: when the receiver does not have to send any reply to the caller (see Subsection 4.1). IMessageAndContext: when the receiver must create and send a reply to the caller. The objects returned by a Contact operation can be used by the application designer to check for the availability of a message or of a reply and to get it. IMessageAndContext public interface IMessageAndContext { public void replytocaller(string msg); public IMessage getreceivedmessage(); } The getreceivedmessage returns the received message, while the replytocaller sends the reply (ack, answer etc.) to the Subject that has sent that message. IAcquireOneReply public interface IAcquireOneReply{ public boolean replyavailable(); public IMessage acquirereply() ; } IAcquireManyReply public interface IAcquireManyReply { public int numofreplyexpected(); public int numofreplyreceived(); public IMessage acquirereply(int n); } The acquirereply operation is a blocking operation that returns a reply message if it is available. The availability of a message can be tested using the replyavailable operation. The availability of a message can be tested using the numofreplyreceived operations, while the numofreplyexpected returns the number of reply that could be received. 3 The impact on the production process This section presents the usage of the Contact language with reference to a (simple) case-study: the definition of a dynamically reconfigurable distributed software system that finds all prime numbers up to a specified integer, using the algorithm known as Sieve of Eratosthenes. The initial system configuration is made of a pipeline of three elements: i) a generator of natural numbers (named intgen) starting from 3; ii) a filter (named filter2) that eliminates all the natural numbers divisible for 2 and iii) a collector of the prime numbers (named sieve). The logical behavior of the system can be informally described as follows. When filter2 receives from intgen anumbernotdivisibleby2 (i.e. 3),itsendssuchanumberto the sieve that stores it as a prime number. Moreover, filter2 reconfigures the pipeline by creating anewfilterthatwilleliminateallthenumbersdivisibleby3, workingasanewelementofthe pipeline inserted between filter2 and the sieve. Inthisway,thenextnumberthatreachesthe sieve will be 5 and a filter for it will be inserted between the filter for 3 and the sieve. 8

19 The behavior logic of a generic filter can be expressed in Java as follows: FilterN public class FilterN extends Thread{ protected int myprime; protected boolean go = true; protected void execfilterwork() { while (go) { IMessage m = getinput(); handleinput( m.msgcontent() ); }// while }} FilterN: handleinput protected String nextfilter = null; protected void handleinput(string msg){ if (checkend(msg)) go = false; else{ int n = Integer.parseInt(msg); if (n % myprime == 0) showmsg( "rejects " + n); else if (nextfilter == null){ sendtosieve( ""+n ); nextfilter=createanotherfilter(n); }else sendtonextfilter( ""+n ); }} This component is conceived as a finite state machine (FSM) that runs in its own Thread. The state transitions is performed by the local method handleinput according to the information received in input. For IMessage see Subsection 4.1. The filter2 component can be logically viewed as an instance of filtern. If msg does not include information to terminate, it represents a natural number (n); if n is not divisible for the filter prime number (myprime) then n is sent to the next element of the pipeline. If the nextfilter variable is not bound, the destination element is the sieve; in this case, a new instance of (FilterN) is created, and the nextfilter variable is bound to the name of such anewfilter. If the nextfilter variable is bound, the nextfilter becomes the destination of the next number not divisible for myprime. The filtern class defines the relevant part of the business logic of the system; to make things simpler, the designer can reasonably decide that all the instances of the filtern class belong to the same JVM; in this case the create operation can be defined as follows: FilterN: createanotherfilter public String createanotherfilter( int n ) throws Exception { FilterN filter = new FilterN(n); filter.start(); return filter.getname(); } The FilterN class is quite easy to implement, once that a proper support for communication is given. But before any implementation, the Contact conceptual space helps an analyst or a designer to express (and evaluate) different applicative scenarios 5. From the specification to a working prototype A Contact specification is introduced in three steps: i) first the system components are defined; ii) then the message types are introduced; iii) finally the communication patterns among the components are specified 6. 5 If the conceptual space is not adequate, it is time to extend the Contact meta-model. 6 In a Contact specification there is (at the moment) no sentence related to the component behavior that can be better expressed in a conventional GPL like Java. 9

20 Subject specification ContactSystem sievesystem; Subject class filtern ; Subject intgen ; Subject sieve ; Subject filter2 inherits filtern ; Message specification Signal nextint ; Dispatch isprime ; Invitation nextval ; Request getprime ; Communication specification intgen emit nextint ; filter2 sense nextint ; filtern accept nextval ; filtern ask nextval to filtern ; filtern forward isprime to sieve ; sieve serve isprime ; sieve grant getprime ; Definition of the components. This specification describes the components of the initial configuration of the system, including the fact that the subject filter2 can be viewed as a specialization of a more generic entity called filtern. Definition of the types of the messages. This specification introduces a wide set of message types, so to have an idea of the conceptual space actually supported by Contact. Definition of the communications roles. A set of constrains that describe with a relational flavor the logical architecture of the system. For the sake of simplicity, the datatypes associated to the messages are omitted. Since most of the communication infrastructure is generated by the Contact-ide, the application designer can produce in a very short time a first working prototype of the system (running on a single JVM), with the aim of further improving the mutual understanding with the customer. What the IDE does (see Figure 2). The Contact-ide generates a Java abstract class for each subject. A subject class has the name SubjSupport where Subj is the name of the subject that extends a predefined abstract Thread named Subject. The application designer must define the application logic into the abstract method dojob by designing a proper specific (communicationdriven) state transition sequence of the subject viewed as a FSM. The business logic finds quite rapidly its proper support, by exploiting the generated support classes. Let us start with the method getinput. getinput // FilterN method protected IMessage getinput() throws Exception{ IMessage m = hl_filtern_accept_nextval(); //defined in FilterNSupport return m; //Filter2 method protected IMessage getinput() throws Exception{ IMessage m = hl_filter2_sense_nextint(); //defined in Filter2Support return m; } The methods of filtern that send information to the other components are: FilterN protected void sendtosieve( String ns ) throws Exception{ hl_filtern_forward_isprime_sieve(ns); //defined in FilterNSupport } protected void sendtonextfilter( String ns ) throws Exception { IAcquireOneReply m=hl_filtern_ask_nextval_filtern(ns,nextfilter);//def. in FilterNSupport showmsg( "got " m.acquirereply().msgcontent() ); } To build a first working prototype, the application designer must define a specialized version of each generated subject support. Let us report here a possible version of the remaining applicative classes, by omitting for the moment the fact that the sieve must grant the request getprime (this case will be discussed in Section 4). 10

21 IntGen public class IntGen extends IntGenSupport{ public IntGen(){ super(); } public void dojob() { for( int n=3; n<9; n++) sendnextint(n); endjob(); } protected void sendnextint(int n){ showmsg( " n=" + n ); hl_intgen_emit_nextint(""+n); } protected void endjob() { hl_intgen_emit_nextint("end"); }} Sieve public class Sieve extends SieveSupport{ private boolean go = true; public Sieve() { super(); } public void dojob() { while( go ){ IMessage m = getinput(); handleinput( m.msgcontent() ); }} protected IMessage getinput(){ IMessage m=hl_sieve_serve_isprime();return m;} protected void handleinput(string msg){ if (msg.contains("end")) go = false; else{ int n = Integer.parseInt( msg ); } }} Running the system: TheContact-ide generates one abstract class for the system as a whole with the name ApplMain where Appl is the name of the system. The ApplMain class includes the logic required to initialize global system properties, to build common support components and the subjects, to configure the system and to start each subject. 4 From the prototype to a distributed system Once the first prototype is validated by the customer, the project team can plan the activities required to build a distributed version of the system, for example a version in which the sieve runs on its own JVM and processor. The analyst immediately recognizes that Filter2 must communicate in two different ways: initially by interacting with the sieve by using some network protocol; then, after the creation of a new filer, Filter2 must interact with the new instance of FilterN by using the implementation of the sharedspace on the common memory, as happens in the first prototype. The architecture of the system has been designed in such a way that no change is required in the subject application code. The transition from the prototype to a distributed system can be made by using a different support for the high-level operations to perform; the decision is delegated to the PlatformExpert component of the Contact runtime. A proper support is automatically created as a consequence of a new Contact specification sentence like the following one: sieve serve isprime support=tcp [ host= port=8070]; 4.1 Co-constructive design The transition from a system working into a single JVM to a distributed system cannot be completely transparent to the application logic. 7 The general strategy adopted in Contact is that the content of a message handled at application level could include also information set by the underlying platform, e.g. an exceptionmessage. However, since distributed systems can pose several problems, the point 7 In fact, several things may happen: i) the attempts to connect with a remote (TCP) port could fail; ii) a receiver on a port could decide to wait for a limited amount of time only; iii) an expected answer/reply does not arrive (within a prefixed time interval), and so on. 11

22 here is not how they are solved by Contact, but that the system designer and the application designer must agree on the best way to make these problems detectable and manageable at application level. As the result of the co-constructive work between application and system designers, the architecture of a Contact system is always composed of three main layers: i) the applicative layer that implements the business logic; ii) an application-support layer (built by a custom software factory) that provides the set of high-level operations required by the business logic; iii) the Contact infrastructure layer based on some implementation of ILindaLike (Section 2) 8. This architecture can be viewed as the result of a conventional design process based on the layer pattern. In our case however, the interfaces provided by each layer are the result of an explicit modeling action and the implementation code is obtained as a M2M transformation based on a stack of languages, each expressing a meta-model and each associated with its own software factory. At the top of the language stack there is Contact, while at the bottom there is a low-level language called corecl that captures the idea that, in order to communicate, two entities must share some medium (e.g. a shared memory space, a communication network, etc.). Between the two there is the intermediate language medcl introduced in Section 2, that defines a set of abstract types of communication operations. The formal definition of the meaning of Contact is performed in two steps, as shown in Figure 1. The M2MContactToMed transformer is a M2M mapper that translates a Contact into an instance of the medcl meta-language. The M2MMedToCore transformer is another M2M mapper that translates a medcl specification into an instance of corecl. The msgcl meta-model defines the structure of the message exchanged at intermediate level; at application level, this structure is expressed by the IMessage interface that follows. Figure 1. M2M transformation chain IMessage public interface IMessage extends IBasicMessage{ public String msgemitter(); public String msgid(); public String msgcontent(); public String msgnum(); } IBasicMessage public interface IBasicMessage { public String getmsgname(); public String getmsgcontent(); public int getmsgseqnum(); } The message interfaces reflect the two layers composing the Contact runtime system and subsume most of the knowledge shared between application and system designers. The application designers can handle the messages by using the IMessage interface only, by ignoring their concrete representation. However, making the structure of messages explicitly visible can improve the understanding of the system and the confidence of application designers in using 8 The implementation on common memory is provided by a class named LindaLike, while the implementation on a network connection is given by a set of objects organized according to suited design patterns. 12

23 the supports provided by the system designer 9. For this reason, all the messages exchanged within a Contact system are made observable at application level, by using a -o option in the system declaration sentence (e.g. ContactSystem sievesystem -o). When the -o option is selected, the Contact-ide generates a default observer 10 that shows that the internal structure of the messages is 11 : mmm( channelid(subjectid,msgid,content,msgnum), seqnum ) The message representation supports the different Contact communications forms. The structure of the channelid reveals how the sharedspace an abstraction that inherently provides many-tomany communications among time-uncoupled subjects can implement also P2P Contact messages (dispatches, invitations, requests). If two subjects named s1 and s2 declare to send a message with msgid=m to a same subject r, conceptually they make reference to a same logical channel with channelid=r m. The channels s1 r m and s2 r m are used to carry an answer/reply. A (TCP) network connection is viewed as an alternative communication medium. Since each message describes its own logical connection, a single (TCP) connection can be used to support all the P2P communications among the subjects running on the two connected nodes. Multi input. The Figure 2 shows a picture of the Contact-ide gui for the sievesystem and the application code of the sieve subject, that handles two kinds of messages: the dispatch isprime and the request getprime. The methods prepareinput and selectoneinput are provided by the system designer to reduce the complexity of the application code when asubjectmustmanageseveralpossible inputs. prepareinput builds the list of queries to be given as argument to selectoneinput, thatfindsamessage in the local sharedspace that unifies with one of the queries. The receiver works as a local proxy of the sender subject by substituting itself to the real caller; thus the code of a subject is made independent of any network protocol. This goal is achieved by forwarding the message with a modified emitter name into the local sharedspace, asshownbythestructure of messages. sieve isprime( proxyfilter2,isprime,3,0) Figure 2. The Contact-ide 9 Another aspect is the possibility to exploit the sharedspace as an internal knowledgebase that can be consulted at run time to reason about communications. 10 An observer can be also defined by the application designer since the LindaLike class is defined as an observable according to the Observer design pattern. 11 AmessageincludesthesubjectId of the sender; thus a receiver can communicate with a subject that it statically does not known. 13

24 5 Related works and conclusions Software development is a collaborative effort where groups of developers need to maintain (contextual) awareness 12 of how particular tasks or project artifacts are progressing. Since distributed software development offers several theoretical benefits over collocated settings 13, a number of tools and models have been developed (a survey can be found in [5]) to enhance contextual awareness in distributed software development. For example, IBM Jazz [6] aims at introducing a distributed collaboration environment by providing a real-time platform based on the Eclipse IDE for integrating work across the different phases of a software development lifecycle. The Rational Team Concert (RTC) [7] is a plug-in to Jazz that enables contextual awareness by mining relational properties of entities within shared software projects. The relational view of RTC offers the potential to enhance traceability and the monitoring of the state of different entities within aproject. The main vision behind our work is that an important set of relationships formed during the development of modern distributed software systems is often related to the collaboration between two main roles of developers: application designers and system designers; these relationships both structural and social are supposed here to be based on direct and indirect links among the artifacts that comprise a model-driven project. In this vision, since software teams often think by means of the models they design and build [5], the conceptual space related to the meta-models becomes a crucial aspect not only for the common understanding required in every cooperation, but also to achieve an appropriate expressive power during software production. In this perspective, Contact the custom language for communication among software componenets discussed in this work is viewed as a tool able to promote reasoning and cooperation, and the related Contact-ide as an environment able to play an active role in driving cognitive processes in all the phases of a software production: in the analysis phase, to express the interaction implied by the business logic of the problem (abstracting from specific communication supports); in the design phase to define (in a technology-independent way) the overall architecture of the system; in the implementation phase, to improve code readability, modularity and platform independence. The idea of model-driven cooperation around custom languages requires a deep integration between the concepts of domain-specific language (DSL) with the MDSD approach and finds an excellent support by the XText technology, founded on the Eclipse ecosystem. As advocated by the proposers of the Projectional Editing concept 14 [8], in Contact the abstract representation is considered the core definition of a system and the models (expressed as instances of the 12 A context refers to the set of circumstances or facts that surround a particular event or situation, including part of a process with different state transitions. 13 e.g. shortened time-to-market cycles, more rapid response to customer needs, a more effective resource pooling, etc 14 An alternative to SourceEditing is the idea that the core definition of a system should be held in a model and edited through projections 14

25 medcl and corecl metamodels) are conceptually decoupled from their representation (expressed by the Contact specification). templates. Moreover, the stack of Contact meta-models leads to a natural decomposition of a system into a set of layers, each related to a proper (abstract) language and built by a proper software factory. The Contact stack can be used/extended to capture more evolute forms of communication (e.g. those proposed by FIPA [9])). The required cooperative work will be inherently related to the organization of the software architecture and based on artifacts built using languages with a well-defined operational semantics. Without understating the concept of active externalism [10], language semantics is considered here an essential requirement to create contextual awareness information useful to initiate contacts among people, to avoid misunderstanding and to improve the organization of the software production and of the resulting products. The slogan coined by James Hendler for the Semantic Web can be adopted also here: a little semantics goes a long way. One of our possible future works is to investigate how this kind of organization can be supported by Jazz and wether it can be profitably included in the ETC project [11]. References 1. Natali, A., Molesini, A.: Towards model-driven communications. In Ardil, C., ed.: World Academy of Science, Engineering and Technology. Volume 64., Rome, Italy, Academic Science Research (2010) International Conference on Software Engineering and Technology (ICSET 2010). 2. Stahl, T., Voelter, M.: Model-Driven Software Development. Wiley (2006) 3. Steinberg, D., Budinsky, F., Paternostro, M., Merks, E.: EMF: Eclipse Modeling Framework, 2nd Edition. Addison-Wesley Professional (2009) 4. The Eclipse Foundation: XText site: Home page. (2011) 5. Omoronyia, I., Ferguson, J., Roper, M., Wood, M.: Using developer activity data to enhance awareness during collaborative software development. Computer Supported Cooperative Work - The Journal of Collaborative Computing 18 (2009) IBM: Home page. (2011) 7. Krishna, S., Fenstermaker, T.: IBM Rational Team Concert 2 Essentials. Packt Publishing (2011) 8. Merkle, B.: Textual modeling tools: overview and comparison of language workbenches. In: Proceedings of the ACM international conference companion on Object oriented programming systems languages and applications companion, SPLASH 10, New York, NY, USA, ACM (2010) IEEE FIPA Design Process Documentation and Fragmentation: IEEE FIPA Design Process Documentation and Fragmentation Homepage. (2009) 10. Clark, A., Chalmers, D.: The Extended Mind. The MIT Press (1998) 11. Coccoli, M. Maresca, P., Stanganelli, L.: Enfrocing team cooperation using rational software tools into software engineering academic project. In Coccoli, M., ed.: Eclipse-IT Volume , Savona, Italy, Eclipse Italian Community (2010) The Fifth Workshop of the Italian Eclipse Community. 15

26 Enabling End-User Plug-in Compositions with MASH Leonardo Mariani and Fabrizio Pastore University of Milano - Bicocca Viale Sarca 336, Milano, Italy {mariani,pastore}@disco.unimib.it Abstract. The majority of IDEs are built upon plug-in architectures that support the integration and execution of different tools on a same environment. The current trend is thinking IDEs as craftsman tables that make available a number of ready-to-use tools. Similarly to craftsmen who combine tools according to tasks that need to be completed, software developers need to dynamically and flexibly compose software tools to effectively develop and analyze software. Unfortunately, IDEs provide little support to the design of tool compositions that have not been foreseen by plug-in developers. Any type of custom analysis must be manually coded from the plug-in API. It results that plug-in integration remains a complex activity reserved to expert plug-in developers with a deep understanding of the underlying environment. This paper describes MASH, an Eclipse plug-in that augments the Eclipse IDE with the concepts of Plug-in Tasks and Workflow of Plug-in Tasks. In our vision, IDE users must be able to integrate both plug-ins and their results by using simple visual formalisms, with limited, and possibly without, coding effort. The MASH workflows go into this direction supporting plug-in execution, plug-in integration, and hierarchical composition of workflows. Plug-in developers can design plug-ins that export functionality as executable tasks (Task-Based plug-ins) ready to be integrated within MASH workflows. The effort of translating regular plug-ins into Task-Based plug-ins is particularly small thank to the task extraction process described in this paper, which is based on the TPTP capture and replay technology. Early experience with MASH confirms our intuition that MASH workflows can be used to quickly implement custom analyses, without requiring significant knowledge about the IDE and the plug-ins API. Keywords: Software Engineering, Plug-ins Composition, Visual Languages 16

27 1 Introduction Modern integrated development environments (IDEs) like Eclipse 1, Netbeans 2 or Microsoft Visual Studio 3 are based on plug-in architectures that allow users installing new plug-ins to extend the original IDE functionalities. For example Java developers using Eclipse can install JUnit 4 to automate test case execution, and Eclemma 5 to measure code coverage. The availability of multiple tools in a same environment eases the invention of new analyses that require tool integration. For example software developers can easily obtain a debugging technique by integrating JUnit and Eclemma: JUnit can execute test cases; Eclemma can identify the lines of code covered by each test case; and the likely fault locations can be identified by computing the lines of code that are executed by the failing test cases but are not executed by the passing test cases (well-known automatic debugging techniques like Tarantula [3] are built upon this intuition). Even if integration is simplified by plug-in architectures, IDEs provide little support to the design and automation of tool compositions that have not been foreseen by plug-in developers. Any type of custom composition must be manually coded from the plug-in API. For example, comparing the lines of code executed by failed and passed test cases requires the implementation of a new plug-in, which implies understanding both the specific plug-in architecture that must be used (in our example the Eclipse architecture) and the APIs of the plug-ins that must be composed (in our example JUnit and Eclemma). It results that plug-in integration remains a complex activity reserved to expert plug-in developers with a deep understanding of the underlying environment. This paper presents MASH, a framework that augments IDEs with the concepts of Task-Based Plug-ins (TB-Plugins) and Workflow of TB-Plugins. In our vision, IDE users must be able to integrate both plug-ins and their results by using simple visual formalisms, with limited, and possibly without, coding effort. MASH goes into this direction by supporting the definition and execution of workflows that combine plug-in functionalities. A TB-plug-in is a plug-in that exposes its core functionalities as tasks that may be composed by end-users in workflows. Plug-ins commonly provide functionalities through widgets (e.g. buttons) that are available to IDE users through a GUI, and APIs that are used by the plug-in developers who want to reuse plug-in functionalities. MASH bridges the gap between the user and programmer views by: providing a visual editor for the definition of workflows that execute multiple tools (implemented as Eclipse plug-ins) and integrate tool results. Workflows