117 research outputs found
Contrôler la visibilité des aspects avec Aspectboxes, X-Editorial-Board = yes, X-International-Audience = no, X-Language = FR, X-Proceedings = yes
National audienceLa composition et l'intéraction des aspects est un domaine de recherche très actif. Bien que plusieurs solutions existent, telles que l'agencement des aspects et des advices, les approches proposées par des langages à aspects supposent qu'une connaissance générale des aspects soit nécessaire pour pouvoir les composer, et même ceci ne permet pas d'éviter les interactions implicites résultant d'une composition. Cet article présente les aspectboxes, un mécanisme de visibilité pour aspects. L'unité élémentaire de visibilité est un aspectbox. Un aspectbox encapsule des définitions d'aspects. Un aspectbox peut être utilisé par d'autres aspectboxes pour aider la construction incrémentale de logiciel à base d'aspects. Une classe peut utiliser un aspectbox dans le but de bénéficier des aspects définis
PerfVis: Pervasive Visualization in Immersive AugmentedReality for Performance Awareness
Developers are usually unaware of the impact of code changes to the
performance of software systems. Although developers can analyze the
performance of a system by executing, for instance, a performance test to
compare the performance of two consecutive versions of the system, changing
from a programming task to a testing task would disrupt the development flow.
In this paper, we propose the use of a city visualization that dynamically
provides developers with a pervasive view of the continuous performance of a
system. We use an immersive augmented reality device (Microsoft HoloLens) to
display our visualization and extend the integrated development environment on
a computer screen to use the physical space. We report on technical details of
the design and implementation of our visualization tool, and discuss early
feedback that we collected of its usability. Our investigation explores a new
visual metaphor to support the exploration and analysis of possibly very large
and multidimensional performance data. Our initial result indicates that the
city metaphor can be adequate to analyze dynamic performance data on a large
and non-trivial software system.Comment: ICPE'19 vision, 4 pages, 2 figure, conferenc
Challenges to support automated random testing for dynamically typed languages
International audienceAutomated random testing is a proven way to identify bugs and precondition violations, and this even in well tested libraries. In the context of statically typed languages, current automated random testing tools heavily take advantage of static method declaration (argument types, thrown exceptions) to constrain input domains while testing and to identify errors. For such reason, automated random testing has not been investigated in the context of dynamically typed languages. In this paper we present the key challenges that have to be addressed to support automated testing in dynamic languages
Assessing the Quality of your Software with MoQam
International audienceOver the last decade, the need for quality in software has increased. Several quality models have been proposed [4, 6, 11]. These mod- els emphasize the need to have quality checks while developing a software program. As far as we are aware of, no model to assess quality of existing software have reached a significant acceptance. This paper describes the Qualixo quality model. Qualixo is an open-source quality model developed by several companies and pushed further in the context of the Squale research project. Ac- cording to Marinescu and Ratiu [9], Qualixo can be classified as a Factor-Criteria-Metrics quality model. Qualixo is being applied in large companies such as AirFrance or PSA. It uses measurements to assess software quality. These measurements cover a number of different aspects of a software, including specification accuracy, programming rules, and test coverage. Qualixo has been origi- nally implemented on top of Eclipse. In this paper we present Mo- Qam (Moose Quality Assessment Model), the implementation of the Qualixo quality model in the Moose open-source reengineering environment
Classbox/J: Controlling the Scope of Change in Java
International audienceUnanticipated changes to complex software systems can introduce anomalies such as duplicated code, suboptimal inheritance rela- tionships and a proliferation of run-time downcasts. Refactoring to eliminate these anomalies may not be an option, at least in certain stages of software evolution. Classboxes are modules that restrict the visibility of changes to selected clients only, thereby offering more freedom in the way unanticipated changes may be imple- mented, and thus reducing the need for convoluted design anoma- lies. In this paper we demonstrate how classboxes can be imple- mented in statically-typed languages like Java. We also present an extended case study of Swing, a Java GUI package built on top of AWT, and we document the ensuing anomalies that Swing intro- duces. We show how Classbox/J, a prototype implementation of classboxes for Java, is used to provide a cleaner implementation of Swing using local refinement rather than subclassing
JSClassFinder: A Tool to Detect Class-like Structures in JavaScript
With the increasing usage of JavaScript in web applications, there is a great
demand to write JavaScript code that is reliable and maintainable. To achieve
these goals, classes can be emulated in the current JavaScript standard
version. In this paper, we propose a reengineering tool to identify such
class-like structures and to create an object-oriented model based on
JavaScript source code. The tool has a parser that loads the AST (Abstract
Syntax Tree) of a JavaScript application to model its structure. It is also
integrated with the Moose platform to provide powerful visualization, e.g., UML
diagram and Distribution Maps, and well-known metric values for software
analysis. We also provide some examples with real JavaScript applications to
evaluate the tool.Comment: VI Brazilian Conference on Software: Theory and Practice (Tools
Track), p. 1-8, 201
Identifying cycle causes with Enriched Dependency Structural Matrix
International audienceDependency Structure Matrix (DSM) has been successfully applied to identify software dependencies among packages and subsystems. A number of algorithms were proposed to compute the matrix so that it highlights patterns and problematic dependencies between subsystems. However, existing DSM implementations often miss important informa- tion to fully support reengineering effort. For example, they do not clearly qualify and quantify problematic relationships, information which is crucial to support remediation tasks. In this paper we present enriched DSM (eDSM) where cells are enriched with contextual information about (i) the type of dependencies (inheritance, class reference . . . ), (ii) the proportion of referencing entities, (iii) the proportion of ref- erenced entities. We distinguish independent cycles and stress potentially simple fixes for cycles using coloring information. This work is language independent and has been implemented on top of the Moose reengineering environment. It has been applied to non-trivial case studies among which ArgoUML, and Morphic the UI framework available in two open-source Smalltalks, Squeak and Pharo. Solution to problems identified by eDSM have been performed and retrofitted in Pharo main distribution
Deep into Pharo
International audienceThis is a book on Pharo a programming language available at http://www.pharo.or
PLOMO Associate Team Final Report
The goal of Plomo is to develop new meta tools to improve and bring synergy in the existing infrastructure of Pharo1 (for software development) and the Moose software analysis platform2 (for maintenance). PLOMO will (i) enhance the Opal open compiler infrastructure to support plugin definition, (ii) offer an infrastructure for change and event tracking as well as models to compose and manipulate them, (iii) work on a layered library of algorithms for the Mondrian visualization engine of Moose, (iv) work on new ways of profiling applications. All the efforts will be performed on Pharo and Moose, two platforms heavily used by the RMoD and Pleiad teams
- …