Network


Latest external collaboration on country level. Dive into details by clicking on the dots.

Hotspot


Dive into the research topics where Mario Südholt is active.

Publication


Featured researches published by Mario Südholt.


aspect-oriented software development | 2004

Composition, reuse and interaction analysis of stateful aspects

Rémi Douence; Pascal Fradet; Mario Südholt

Aspect-Oriented Programming promises separation of concerns at the implementation level. However, aspects are not always orrthogonal and aspect interaction is a fundamental problem. In this paper, we extend previous work on a generic framework for the formal definition and interaction analysis of stateful aspects. We propose three important extensions which enhance expressivity while preserving static analyzability of interactions. First, we provide support for variables in aspects in order to share information between different execution points. This allows the definition of more precise aspects and to avoid detection of spurious conflicts. Second, we introduce generic composition operators for aspects. This enables us to provide expressive support for the resolution of conflicts among interacting aspects. Finally, we offer a means to define applicability conditions for aspects. This makes interaction analysis more precise and paves the way for reuse of aspects by making explicit requirements on contexts in which aspects must be used.


generative programming and component engineering | 2002

A Framework for the Detection and Resolution of Aspect Interactions

Rémi Douence; Pascal Fradet; Mario Südholt

Aspect-Oriented Programming (AOP) promises separation of concerns at the implementation level. However, aspects are not always orthogonal and aspect interaction is an important problem. Currently there is almost no support for the detection and resolution of such interactions. The programmer is responsible for identifying interactions between conflicting aspects and implementing conflict resolution code.In this paper, we propose a solution to this problem based on a generic framework for AOP. The contributions are threefold: we present a formal and expressive crosscut language, two static conflict analyses and some linguistic support for conflict resolution.


Lecture Notes in Computer Science | 2001

A Formal Definition of Crosscuts

Rémi Douence; Olivier Motelet; Mario Südholt

Crosscutting, i.e. relating different program points is one of the key notions of Aspect-Oriented Programming. In this article, we consider a general and operational model for crosscutting based on execution monitors.A domain-specific language for the definition of crosscuts constitutes the core of the article. The semantics of this language is formally defined by means of parser operators matching event patterns in execution traces. We define an operational semantics of the matching process by means of rules relating the operators.The use of the language is exemplified by several sophisticated crosscut detinitions. We sketch a prototype implementation in JAVA which has been systematically derived from the language definition.


aspect-oriented software development | 2006

Explicitly distributed AOP using AWED

Luis Daniel Benavides Navarro; Mario Südholt; Wim Vanderperren; Bruno De Fraine; Davy Suvée

Distribution-related concerns, such as data replication, often crosscut the business code of a distributed application. Currently such crosscutting concerns are frequently realized on top of distributed frameworks, such as EJBs, and initial AO support for the modularization of such crosscutting concerns, e.g., JBoss AOP and Spring AOP, has been proposed.Based on an investigation of the implementation of replicated caches using JBoss Cache, we motivate that crosscutting concerns of distributed applications benefit from an aspect language for explicit distributed programming. We propose AWED, a new aspect language with explicit distributed programming mechanisms, which provides three contributions. First, remote pointcut constructors which are more general than those of previous related approaches, in particular, supporting remote sequences. Second, a notion of distributed advice with support for asynchronous and synchronous execution. Third, a notion of distributed aspects including models for the deployment, instantiation and state sharing of aspects. We show several concrete examples how AWED can be used to modularly implement and extend replicated cache implementations. Finally, we present a prototype implementation of AWED, which we have realized by extending JAsCo, a system providing dynamic aspects for Java.


aspect-oriented software development | 2005

An expressive aspect language for system applications with Arachne

Rémi Douence; Thomas Fritz; Nicolas Loriant; Jean-Marc Menaud; Marc Ségura-Devillechaise; Mario Südholt

C applications, in particular those using operating system level services, frequently comprise multiple crosscutting concerns: network protocols and security are typical examples of such concerns. While these concerns can partially be addressed during design and implementation of an application, they frequently become an issue at runtime, e.g., to avoid server downtime. A deployed network protocol might not be efficient enough and may thus need to be replaced. Buffer overflows might be discovered that imply critical breaches in the security model of an application. A prefetching strategy may be required to enhance performance.While aspect-oriented programming seems attractive in this context, none of the current aspect systems is expressive and efficient enough to address such concerns. This paper presents a new aspect system to provide a solution to this problem. While efficiency considerations have played an important part in the design of the aspect language, the language allows aspects to be expressed more concisely than previous approaches. In particular, it allows aspect programmers to quantify over sequences of execution points as well as over accesses through variable aliases. We show how the former can be used to modularize the replacement of network protocols and the latter to prevent buffer overflows. We also present an implementation of the language as an extension of Arachne, a dynamic weaver for C applications. Finally, we present performance evaluations supporting that Arachne is fast enough to extend high performance applications, such as the Squid web cache.


aspect-oriented software development | 2008

StrongAspectJ: flexible and safe pointcut/advice bindings

Bruno De Fraine; Mario Südholt; Viviane Jonckers

AspectJ was designed as a seamless aspect-oriented extension of the Java programming language. However, unlike Java, AspectJ does not have a safe type system: an accepted binding between a pointcut and an advice can give rise to type errors at runtime. In addition, AspectJs typing rules severely restrict the definition of certain generic advice behavior. In this paper, we analyze the roots of these type errors, and describe measures to recover type safety for both generic and non-generic pointcut/advice declarations. Pointcuts quantify over heterogeneous sets of join points and are hence typed using type ranges in our approach, while type variables and a dual advice signature allow to express the generic and invasive nature of advices. Using these mechanisms, we can express advice that augments, narrows or replaces base functionality in possibly generic contexts. As a language engineering contribution, we integrate our proposal with the AspectJ language, and we provide a prototype implementation as a plugin for the AspectBench Compiler (abc). On a theoretical level, we present a formal definition of the proposed constructs and typing rules, and develop proofs for their type safety properties.


generative programming and component engineering | 2006

Concurrent aspects

Rémi Douence; Didier Le Botlan; Jacques Noyé; Mario Südholt

Aspect-Oriented Programming (AOP) promises the modularization of so-called crosscutting functionalities in large applications. Currently, almost all approaches to AOP provide means for the description of sequential aspects that are to be applied to a sequential base program. In particular, there is no formally-defined concurrent approach to AOP, with the result that coordination issues between aspects and base programs as well as between aspects cannot precisely be investigated.This paper presents Concurrent Event-based AOP (CEAOP), which addresses this issue. Our contribution can be detailed as follows. First, we formally define a model for concurrent aspects which extends the sequential Event-based AOP approach. The definition is given as a translation into concurrent specifications using Finite Sequential Processes (FSP), thus enabling use of the Labelled Transition System Analyzer (LTSA) for formal property verification. Further, we show how to compose concurrent aspects using a set of general composition operators. Finally, we sketch a Java prototype implementation for concurrent aspects, which generates coordination specific code from the FSP model defining the concurrent AO application.


automated software engineering | 2003

On the automatic evolution of an OS kernel using temporal logic and AOP

Rickard A. Åberg; Julia L. Lawall; Mario Südholt; Gilles Muller; Anne-Françoise Le Meur

Automating software evolution requires both identifying precisely the affected program points and selecting the appropriate modification at each point. This task is particularly complicated when considering a large program, even when the modifications appear to be systematic. We illustrate this situation in the context of evolving the Linux kernel to support Bossa, an event-based framework for process-scheduler development. To support Bossa, events must be added at points scattered throughout the kernel. In each case, the choice of event depends on properties of one or a sequence of instructions. To describe precisely the choice of event, we propose to guide the event insertion by using a set of rules, amounting to an aspect that describes the control-flow contexts in which each event should be generated. In this paper, we present our approach and describe the set of rules that allows proper event insertion. These rules use temporal logic to describe sequences of instructions that require events to be inserted. We also give an overview of an implementation that we have developed to automatically perform this evolution.


ieee international conference on cloud computing technology and science | 2012

Accountability for cloud and other future Internet services

Siani Pearson; Vasilios Tountopoulos; Daniele Catteddu; Mario Südholt; Refik Molva; Christoph Reich; Simone Fischer-Hübner; Christopher Millard; Volkmar Lotz; Martin Gilje Jaatun; Ronald Leenes; Chunming Rong; Javier Lopez

Cloud and IT service providers should act as responsible stewards for the data of their customers and users. However, the current absence of accountability frameworks for distributed IT services makes it difficult for users to understand, influence and determine how their service providers honour their obligations. The A4Cloud project will create solutions to support users in deciding and tracking how their data is used by cloud service providers. By combining methods of risk analysis, policy enforcement, monitoring and compliance auditing with tailored IT mechanisms for security, assurance and redress, A4Cloud aims to extend accountability across entire cloud service value chains, covering personal and business sensitive information in the cloud.


IEEE Computer | 2010

Aspect-Oriented Software Development in Practice: Tales from AOSD-Europe

Awais Rashid; Thomas Cottenier; Philip Greenwood; Ruzanna Chitchyan; Regine Meunier; Roberta Coelho; Mario Südholt; Wouter Joosen

Aspect-oriented software development techniques provide a means to modularize crosscutting concerns in software systems. A survey of industrial projects reveals the benefits and potential pitfalls of aspectoriented technologies.The past decade has seen the increased use of aspect-oriented software development (AOSD) technique as a means to modularize crosscutting concerns in software systems, thereby improving a development organizations working practices and return on investment (ROI). Numerous industrial-strength aspect-oriented (AO) programming frameworks exist, including AspectJ, JBoss, and Spring, as do various aspect-oriented analysis and design techniques.The software systems using AOSD that we have studied are medium to large-scale and span a wide range of domains including enterprise systems, e-health, e-transport, telecommunications, Web based information systems, multimedia applications, and workflow systems. Our analysis highlights typical usage patterns of AO techniques-for instance, they are mainly used for modularizing well-known crosscutting problems and incrementally introduced, addressing developmental concerns and other noncore product features first.

Collaboration


Dive into the Mario Südholt's collaboration.

Top Co-Authors

Avatar

Rémi Douence

École des mines de Nantes

View shared research outputs
Top Co-Authors

Avatar

Jean-Marc Menaud

École des mines de Nantes

View shared research outputs
Top Co-Authors

Avatar
Top Co-Authors

Avatar

Jean-Claude Royer

École des mines de Nantes

View shared research outputs
Top Co-Authors

Avatar
Top Co-Authors

Avatar
Top Co-Authors

Avatar
Top Co-Authors

Avatar

Hervé Grall

École des mines de Nantes

View shared research outputs
Top Co-Authors

Avatar
Top Co-Authors

Avatar

Bruno De Fraine

Vrije Universiteit Brussel

View shared research outputs
Researchain Logo
Decentralizing Knowledge