Electronic Communications of the EASST (European Association of Software Science and Technology)
Not a member yet
887 research outputs found
Sort by
Towards an Analysis of Who Creates Clone and Who Reuses it
Get PDFCode clone analysis is valuable because it can reveal reuse behaviours efficientlyfrom software repositories. Recently, some code reuse analyses using clonegenealogies and code clones over multiple projects were conducted. However, mostof the conventional analyses do not consider the developers’ individual difference toreuse behaviors. In this paper, we propose a method for code reuse analysis whichtakes particular note of the differences among individuals. Our analysis methodclarifies who reused whose source code across multiple repositories. We believethe result might provide us with constructive perceptions such as characteristics ofreused code itself by multiple developers, and developers who implement reusablecode
About Metrics for Clone Detection
Get PDFClone detectors rely on the concept of similarity and dissimilarity measures to identify cloned fragments. The choice of specific distance function in a clone detector is arbitrary up to some extent. However, with a deeper knowledge of similarity measures, we can condition this choice to have some properties that can help improve scalability and quality of tools. This paper presents some interesting results, insights and questions about similarity and dissimilarity measures, including a somehow counter-intuitive result on the cosine distance
Measuring Copying of Java Archives
Get PDFCopying the whole of a library is one of the major types of reuse in software development.In Java, a single library archive file often contains other libraries it depends on, but users of the library hardly know about such inner libraries.Since reusing libraries is a black-box method, developers may combine some librarieswithout knowing that those libraries contain the same library inside independently.As a result, a library may contain inside several copies of a library it reuses.In this research, we measured copying of jar archives in the Maven Central Repository, a collection of open source Java libraries.Our results show that about 14% of top-level jar files are reused in other jar filesand some of them are duplicated in a single jar file.We also found that some libraries contain two or more different versions of the same library
Compositional Verification of a Lock-Free Stack with RGITL
Get PDFThis paper describes a compositional verification approach for concurrentalgorithms based on the logic Rely-Guarantee Interval Temporal Logic (RGITL),which is implemented in the interactive theorem prover KIV. The logic makes itpossible to mechanically derive and apply decomposition theorems for safety andliveness properties. Decomposition theorems for rely-guarantee reasoning, linearizability and lock-freedom are described and applied on a non-trivial running example,a lock-free data stack implementation that uses an explicit allocator stack for memory reuse. To deal with the heap, a lightweight approach that combines ownershipannotations and separation logic is taken
Active Clones: Source Code Clones at Runtime
Get PDFCode cloning is a common programming practice, and there have been aconsiderable amount of research that investigated the implications of code clones onsoftware maintenance using static analysis. However, little has been done to investigatethe runtime implications of code cloning. In this paper we investigate sourcecode clones at runtime, referring to clones as ‘active clones’ if they are invokedwhen a software system is in use. For example, if a particular use u of a systemresults in a clone c being invoked, we say that clone c is active with respect to useu. From this definition and given a set of uses fu1;u2; :::g and clones fc1;c2; :::gwe are able to identify the extent clones are active at runtime and analyze activeclone resource use (e.g., CPU time) and define and calculate a set of active clonemetrics to provide insights into source code cloning implications at runtime. We developeda hybrid static and dynamic analysis technique for detecting and analysingactive clones, and conducted an empirical study on five software systems (HSQLDB,JHotDraw, RText, jEdit and UniCentaoPOS) to validate our approach. We found asmall portion of clones are active during a typical use of a software system, and thatactive clones have the potential for guiding a software developer’s code inspectionactivity during a software maintenance task
Towards Bridging the Expressiveness Gap Between \linebreak Relational and Deductive Databases
No full textSQL technology has evolved during last years, and systems are becoming more powerful and scalable. However, there exist yet some expressiveness limitations that can be otherwise overcome with inputs from deductive databases. This paper focuses on both practical and theoretical expressiveness issues in current SQL implementations that are overcome in the Datalog Educational System (DES), a deductive system which also includes extended SQL queries with respect to the SQL standard and current DBMS's. Also, as external database access and interoperability are allowed in DES, results from the deductive field can be tested on current DBMS's. For instance: Less-limited SQL formulations as non-linear recursive queries, novel features as hypothetical queries, and other query languages as Datalog and Extended Relational Algebra. In addition, some notes on performance are taken
The highs and lows of deploying Formal Methods in Industry
Get PDFI attended my first software conference in 1968; it was organised by NATO with the title “The Software Crisis.” Many of the papers presented then could have been written yesterday; the problems of the software industry in producing reliable, correct software in the face of increasing complexity and shrinking time to market pressures have not fundamentally changed that much.In the intervening years as a community we have developed various tactics for trying to minimise software errors. Advances in theorem proving and model checking are good examples of systematic efforts to improve software correctness. Nevertheless, it remains the case that such approaches are rarely if ever encountered in the industrial workplace, with the possible exception of some safety critical domains, such as the software controlling nuclear power plants.In spite advances in formal methods and supporting tools, the tools available to programmers for verifying assertions about program execution are complex and require knowledge and skills that most practicing programmers do not have. Formal proofs remain difficult to construct, especially for anything but the simplest of programs. Merely constructing assertions to characterise program correctness is a difficult challenge.In 1998, I conceived the idea of combing model checking, code generation and the specification approach of Sequence-based Specification together to form an integrated software design platform for developing software components whose design (implementation) would be formally verified for correctness with respect to its specification. Other general correctness properties such as freedom from deadlocks, non-determinism, incomplete cases, etc. would also be verified. Verification would be performed by automatically translating Sequence-based specifications into semanti- cally equivalent CSP process algebra and then applying the model-checking engine FDR2. After verification was completed, semantically equivalent source code would be generated in one of several supported high-level languages.These ideas were developed further together with Philippa Hopcroft and in 2003 a company was founded to develop a commercial implementation of a development platform based on these ideas. In this talk, I will present an overview of the develop-ment platform and the technologies used. I will then discuss the experience gained during 10 years of trying to introduce this approach into industry and the lessons learned along the way
Building Traceable Event-B Models from Requirements
Get PDFConstructing traceable Event-B models from requirements is crucial in the system development process. It enables the validation of the model against the requirements and allows to identify different refinement levels, which is a key to successful formal modelling with a refinement-based method. Our objective is to present an approach based on the use of semi-formal structures to bridge the gap between requirements and Event-B models and retain traceability to requirements in Event-B models. The presented approach makes use of the UML-B and Atom- icity Decomposition (AD) approaches. UML-B provides UML graphical notation that enables the development of an Event-B formal model, while the AD approach provides a graphical notation to illustrate the refinement structures and assists in the organisation of refinement levels. The AD approach also combines several con- structor patterns to manage control flows in Event-B. The intent of this paper is to harness the benefits of the UML-B and AD approaches to facilitate constructing Event-B models from requirements and provide traceability between requirements and Event-B models
Lightweight Interaction Modeling in Evolutionary Prototyping
Get PDFThe paper discusses a systematic integration of evolutionary and exploratory prototyping of interactive systems by a lightweight use of formal methods. Formal models guide the development of the underdesigned evolutionary prototype. In combination with techniques from Design Rationale, they implement theexploration and assessment of possible solutions to open design questions. Models and corresponding tool support are used to express design options and to make them more accessible to a broader audience by the creation of parallel model-guided throwaway extensions of the current evolutionary prototype. They are also used to describe design constraints (for example, in terms of tasks or in terms of actions on artifacts) and to assess design options against these criteria. The suggested approach is demonstrated through an example design scenario that shows an intertwining of different design activities and discusses the role of formal models. In particular, the scenario describes a coupling of HOPS models, QOC diagrams, and Java prototypes