Lightweight coarse-grained coordination: a scalable system-level approach

2005

Softw Syst Model

Self Cite

In this paper we present dETI, the next generation of the Electronic Tool Integration (ETI) platform, an open platform for the interactive experimentation with and coordination of heterogeneous software tools via the internet. Our redesign, which is based on the experience gained while running the ETI platform since 1997, focusses on the tool integration process, which clearly marked the bottleneck for the wide acceptance of the ETI platform on the side of an important group of users: the tool providers. The new integration approach makes use of standard Web Services technology, which perfectly fits in the overall ETI architecture.Our approach realizes a clear separation of concerns, which overcomes all the previously observed obstacles by (i) decoupling the integration tasks of the tool providers and the ETI team, (ii) pulling the ETI team out of the upgrading and maintenance loop and (iii) handing the upgrading and access control over to the tool providers.This guarantees the scalability in the number of tools available within ETI, and addresses the flexibility concerns of the tool providers. Motivation and contributionThe Electronic Tool Integration platform (ETI) [33] is an online platform specifically designed to support the distributed use of and experimentation with tools over the internet. Born in 1996 and online since early 1997, it offered a unique service to tool providers and users: its solution for the remote execution of tools and the internet-based administration of user-specific home areas on the ETI server was well ahead of the technology of those times. Since then, users can -retrieve information about the tools, -execute tools in stand-alone mode, or -combine functionalities of different tools to obtain sequential programs called coordination sequences and run them in tool-coordination mode.In particular, users can combine functionalities of tools of different application domains to solve problems a single tool never would be able to tackle. Obviously, the richness of the tool repository plays a crucial role in the success of ETI: maximum benefit can be gained from the experimentation and coordination facilities 1 of the platform if the repository is filled with a large amount and variety of well classified softwaretools. The success of ETI is thus highly sensitive to the process and costs of tool integration.At the same time, our experience shows that the current integration process needs reconsideration: as discussed in Sect. 4, the apparently straightforward integration process is still too demanding to be easily accepted by the tool providers. The effort required to integrate new tools is in fact perceived as too large and too ETIspecific [25]. Although there is a community of interested tool users, insufficient ease of integration becomes the limiting factor. What we need to leverage the technology is thus a much simpler approach to tool integration.In this paper we show how, taking advantage of newer technologies that internally base on Web Services, we can 1 Tool Coordination is the ETI ...

Section: The Tool Description Languagementioning

confidence: 99%

Web services-based tool-integration in the ETI platform

2005

Softw Syst Model

Self Cite

“…The jABC Application Building Center jABC [6], [8] is a mature framework for service development based on Lightweight Process Coordination [16]. jABC and its predecessors have been used since 1995, among others, for Intelligent Network Services design [17][18], Tool Integration [19], Data Flow Analysis (DFA) [14], and Model verification.…”

Section: From Lid To Code Modelsmentioning

confidence: 99%

Analysis and Code Model Extraction for C/C++ Source Code

Wagner

2009 14th IEEE International Conference on Engineering of Complex Computer Systems

Pagendarm³

2009

Self Cite

In the area of re-engineering or re-purposing of existing software, model driven methodologies are hard to adopt because of lack of the central asset: models for the existing source code. Large companies and organizations that maintain a large code basis over long periods of time have recognized this issue, and are looking for ways to turn that code basis into models understandable under a business purposes point of view.In this paper, we introduce a technique that address this issue for C/C++ code. It delivers code-models, a representation of source code close to control flow graphs, by means of tool-supported analysis and transformations from legacy source code. Code models extend usual control flow graphs with rich information on both nodes and edges. They are immediately analyzable and verifiable in the jABC MDD framework, thus adequate for a model driven design, development, and evolution process. I. MOTIVATIONModern software development strategies typically describe the development of new software. But, in real life a huge amount of source code exists, which was developed long before modern strategies came up. In the normal life cycle of software, the source code must be maintained and the functionality extended. Therefore, parts of the software have to be reengineered, repurposed or exchanged.Large companies and organizations that maintain a large code basis over long periods of time have recognized this issue, and are looking for ways to turn that code basis into models understandable under a business purposes point of view. As was made clear by the industrial representatives and NASA project responsibles e.g. at the recent NASA Formal Methods Symposium 1 , their strategic and managerial interest is less on reconstructing the software's structure (feasible for example via class analyses) or some quantitative characterizations e.g. in terms of metrics. It is rather on finding a practical way of entering the purpose-driven MDD that characterizes modern and leading-edge software and systems development from the starting point of the current, outdated, code basis. The central issue is how to get, possibly with automated support, from that legacy code into a purpose-oriented style of modelling that servers as basis for code migration and repurposing.In this paper we show how to use the Model driven design and development (MDD) approach, in order to enable the evolution, redesign, and repurposing process of legacy 1 http://ti.arc.nasa.gov/event/nfm09/ software at the model level, in contrast to a new development from scratch.

“…The jABC and its predecessor ABC have been successfully used in the design and customization of Intelligent Network Services [17], test environments [16,20], distributed online decision support systems [12,11], and Web Services [18][23], and it is currently being used in project for Enterprise Resource Planning (ERP) and Supply Chain Management (SCM) [5].…”

Section: An Amdd-realizationmentioning

confidence: 99%

From the How to the What

Verified Software: Theories, Tools, Experiments

Steffen

2008

Self Cite

Abstract. In this paper, we consider the Grand Challenge under a very specific perspective: the enabling of application experts without programming knowledge to reliably model their business processes/applications in a fashion that allows for a subsequent automatic realization on a given platform. This goal, which aims at simplifying the tasks of the many at the cost of ambitious and laborious tasks for the few, adds a new dimension to the techniques and concepts aimed at by the Grand Challenge: the application-specific design of platforms tailored for the intended goal. We are convinced that the outlined perspective provides a realistic and economically important milestone for the Grand Challenge. MotivationSince the very beginning of computer science, the mismatch between design for machines and design for brains has been a constant pain, and a constant driver for innovation: it was always clear that descriptions that are good for machine processing are inadequate for an intuitive human understanding, and that descriptions which are structured for easy comprehension contain a lot of 'syntactic overhead', that typically slows down their automatic processing.Compilers were designed to overcome, or better to weaken, this mismatch: Rather than trying to construct machines that work as humans think, it seemedmore appropriate to translate comprehensible descriptions into machine-adequate representations. Besides classical compilers that translate high-level programming language into machine code there are also other means of automated code generation from more abstract descriptions: to this group belong parser generators, data flow analysis generators, compiler generators, and all the modern OOtools that translate, e.g., UML descriptions into code fragments. Most drastic are those versions of Model Driven Design (MDD) that aim at totally replacing the need of programming for most application development using model construction. Thus the original desire to lift low-level machine code (prescribing How to run the machine) to more abstract programs (describing What to achieve) has become reality at increasing levels of abstraction from the hardware, and leading to extreme approaches like requirements-based programming, which aims at automatically making the user's or customer's requirements executable.