scholarly journals Annotation Sniffer: A tool to Extract Code Annotations Metrics

2020 ◽  
Vol 5 (47) ◽  
pp. 1960
Author(s):  
Phyllipe Lima ◽  
Eduardo Guerra ◽  
Paulo Meirelles
Keyword(s):  
2010 ◽  
Vol 13 (2) ◽  
Author(s):  
Diego A. A. Correia ◽  
Eduardo M. Guerra ◽  
Fabio F. Silveira ◽  
Clovis T. Fernandes

In order to customize their behavior at runtime, a wide sort of modern frameworks do use code annotations at the applications‟ classes as metadata configuration. However, despite its popularity, this type of metadata definition inserts complexity and semantic coupling that is ignored by traditional software metrics. This paper presents identified bad smells in annotated code and defines new metrics that help in their detection by enabling a quantitative assessment of complexity and coupling in this type of code. Moreover, it proposes some strategies to detect those bad smells by using the defined metrics and introduces an open-source tool created to automate the process of bad smell discovery on annotated code.


2016 ◽  
Vol 74 (11) ◽  
pp. 5659-5673 ◽  
Author(s):  
Marco Danelutto ◽  
Tiziano De Matteis ◽  
Gabriele Mencagli ◽  
Massimo Torquati

Author(s):  
Tom-Michael Hesse ◽  
Arthur Kuehlwein ◽  
Barbara Paech ◽  
Tobias Roehm ◽  
Bernd Bruegge
Keyword(s):  

PLoS ONE ◽  
2021 ◽  
Vol 16 (4) ◽  
pp. e0250306
Author(s):  
Jonas Latt ◽  
Christophe Coreixas ◽  
Joël Beny

We present a novel, hardware-agnostic implementation strategy for lattice Boltzmann (LB) simulations, which yields massive performance on homogeneous and heterogeneous many-core platforms. Based solely on C++17 Parallel Algorithms, our approach does not rely on any language extensions, external libraries, vendor-specific code annotations, or pre-compilation steps. Thanks in particular to a recently proposed GPU back-end to C++17 Parallel Algorithms, it is shown that a single code can compile and reach state-of-the-art performance on both many-core CPU and GPU environments for the solution of a given non trivial fluid dynamics problem. The proposed strategy is tested with six different, commonly used implementation schemes to test the performance impact of memory access patterns on different platforms. Nine different LB collision models are included in the tests and exhibit good performance, demonstrating the versatility of our parallel approach. This work shows that it is less than ever necessary to draw a distinction between research and production software, as a concise and generic LB implementation yields performances comparable to those achievable in a hardware specific programming language. The results also highlight the gains of performance achieved by modern many-core CPUs and their apparent capability to narrow the gap with the traditionally massively faster GPU platforms. All code is made available to the community in form of the open-source project stlbm, which serves both as a stand-alone simulation software and as a collection of reusable patterns for the acceleration of pre-existing LB codes.


2017 ◽  
Vol 59 (4) ◽  
Author(s):  
Maria Christakis

AbstractOur work on narrowing the gap between verification and systematic testing has two directions: (1) complementing verification with systematic testing, and (2) pushing systematic testing toward reaching verification. In the first direction, we explore how to effectively combine static analysis with systematic testing, so as to guide test generation toward properties that have not been previously checked by a static analyzer in a sound way. This combination significantly reduces the test effort while checking more unverified properties. In the second direction, we push systematic testing toward checking as many executions as possible of a real and complex image parser, so as to prove the absence of a certain class of errors. This verification attempt required no static analysis or source code annotations; our purely dynamic techniques targeted the verification of the parser implementation, including complicated assembly patterns that most static analyses cannot handle.


Author(s):  
Carlos R. Jaimez-Gonzalez ◽  
Simon M. Lucas ◽  
Erick J. Lopez-Ornelas

Object serialization is the process of rendering an object into a state that can be stored persistently. Serializing objects to XML brings many advantages over binary encoding because XML is human and computer readable, and it also aims to have better interoperability between different programming languages. This paper presents Web Objects in XML (WOX), an efficient and easy to use XML serializer for C# and Java objects. It allows to serialize Java objects to XML, de-serialize them to C#, and viceversa. Our serialization approach does not need code annotations or any other type of configuration from the user in order to serialize objects. The XML encoding used in our WOX serializer can represent objects in other object-oriented programming languages. We describe the main features and uses of the WOX serializer, its implementation, and the XML representation generated along with some examples.


2020 ◽  
Vol 191 ◽  
pp. 102418 ◽  
Author(s):  
Pedro Pinheiro ◽  
José Carlos Viana ◽  
Márcio Ribeiro ◽  
Leo Fernandes ◽  
Fabiano Ferrari ◽  
...  

Sign in / Sign up

Export Citation Format

Share Document