Eclipse IDE Research Articles

Evaluating a query framework for software evolution data

With the steady advances in tooling to support software engineering, mastering all the features of modern IDEs, version control systems, and project trackers is becoming increasingly difficult. Answering even the most common developer questions can be surprisingly tedious and difficult. In this article we present a user study with 35 subjects to evaluate our quasi-natural language interface that provides access to various facets of the evolution of a software system but requires almost zero learning effort. Our approach is tightly woven into the Eclipse IDE and allows developers to answer questions related to source code, development history, or bug and issue management. The results of our evaluation show that our query interface can outperform classical software engineering tools in terms of correctness, while yielding significant time savings to its users and greatly advancing the state of the art in terms of usability and learnability.

Quantifying the Effect of Code Smells on Maintenance Effort

Context: Code smells are assumed to indicate bad design that leads to less maintainable code. However, this assumption has not been investigated in controlled studies with professional software developers. Aim: This paper investigates the relationship between code smells and maintenance effort. Method: Six developers were hired to perform three maintenance tasks each on four functionally equivalent Java systems originally implemented by different companies. Each developer spent three to four weeks. In total, they modified 298 Java files in the four systems. An Eclipse IDE plug-in measured the exact amount of time a developer spent maintaining each file. Regression analysis was used to explain the effort using file properties, including the number of smells. Result: None of the 12 investigated smells was significantly associated with increased effort after we adjusted for file size and the number of changes; Refused Bequest was significantly associated with decreased effort. File size and the number of changes explained almost all of the modeled variation in effort. Conclusion: The effects of the 12 smells on maintenance effort were limited. To reduce maintenance effort, a focus on reducing code size and the work practices that limit the number of changes may be more beneficial than refactoring code smells.

Complete completion using types and weights

Developing modern software typically involves composing functionality from existing libraries. This task is difficult because libraries may expose many methods to the developer. To help developers in such scenarios, we present a technique that synthesizes and suggests valid expressions of a given type at a given program point. As the basis of our technique we use type inhabitation for lambda calculus terms in long normal form. We introduce a succinct representation for type judgements that merges types into equivalence classes to reduce the search space, then reconstructs any desired number of solutions on demand. Furthermore, we introduce a method to rank solutions based on weights derived from a corpus of code. We implemented the algorithm and deployed it as a plugin for the Eclipse IDE for Scala. We show that the techniques we incorporated greatly increase the effectiveness of the approach. Our evaluation benchmarks are code examples from programming practice; we make them available for future comparisons.

Xbase

Xtext is an open-source framework for implementing external, textual domain-specific languages (DSLs). So far, most DSLs implemented with Xtext and similar tools focus on structural aspects such as service specifications and entities. Because behavioral aspects are significantly more complicated to implement, they are often delegated to general-purpose programming languages. This approach introduces complex integration patterns and the DSL's high level of abstraction is compromised. We present Xbase as part of Xtext, an expression language that can be reused via language inheritance in any DSL implementation based on Xtext. Xbase expressions provide both control structures and program expressions in a uniform way. Xbase is statically typed and tightly integrated with the Java type system. Languages extending Xbase inherit the syntax of a Java-like expression language as well as language infrastructure components, including a parser, an unparser, a linker, a compiler and an interpreter. Furthermore, the framework provides integration into the Eclipse IDE including debug and refactoring support. The application of Xbase is presented by means of a domain model language which serves as a tutorial example and by the implementation of the programming language Xtend. Xtend is a functional and object-oriented general purpose language for the Java Virtual Machine (JVM). It is built on top of Xbase which is the reusable expression language that is the foundation of Xtend.

Web applications design recovery and evolution with RE‐UWA

SUMMARYThis paper presents a semi‐automatic approach for the recovery and evolution of the design of existing Web applications. The proposed approach is structured in two main phases and is based on the Ubiquitous Web Applications (UWA) design framework, a methodology and a set of models and tools for the user‐centered design of multichannel context‐aware Web applications. In the first phase a representative set of the application's front‐end Web pages are analyzed to abstract the ‘as‐is’ design model of the application according to the UWA methodology. In the second phase, the recovered design model is evolved to define the ‘to be’ version of it. This evolution activity considers the up‐to‐date requirements available for the application and UWA design guidelines to identify shortcomings and opportunities of improvement in the ‘as‐is’ design. The reverse modeling phase exploits clustering and clone detection techniques and is supported by the RE‐UWA tool, an Eclipse IDE customized to implement the reverse engineering process defined to extract formal UWA models expressed as instances of a MOF metamodel. The forward design phase is supported by a set of UWA modeling tools that are built on top of the Eclipse Modeling Framework (EMF) and the Eclipse Graphical Modeling Framework (GMF). The proposed design recovery and evolution approach is applied to four real‐world Web applications and the obtained results are also presented in the paper. Copyright © 2012 John Wiley & Sons, Ltd.

Exploiting Dynamic Information in IDEs Improves Speed and Correctness of Software Maintenance Tasks

Modern IDEs such as Eclipse offer static views of the source code, but such views ignore information about the runtime behavior of software systems. Since typical object-oriented systems make heavy use of polymorphism and dynamic binding, static views will miss key information about the runtime architecture. In this paper, we present an approach to gather and integrate dynamic information in the Eclipse IDE with the goal of better supporting typical software maintenance activities. By means of a controlled experiment with 30 professional developers, we show that for typical software maintenance tasks, integrating dynamic information into the Eclipse IDE yields a significant 17.5 percent decrease of time spent while significantly increasing the correctness of the solutions by 33.5 percent. We also provide a comprehensive performance evaluation of our approach.

Best practices for describing, consuming, and discovering web services: a comprehensive toolset

SUMMARYThe service‐oriented computing (SOC) paradigm has recently gained a lot of attention in the software industry because SOC represents a novel and a fresh way of architecting distributed applications. SOC is usually materialized via web services, which allows developers to structure applications exposing a clear, public interface to their capabilities. Although conceptually and technologically mature, SOC still lacks adequate development support from a methodological point of view. In this paper, we present the EasySOC project, a set of guidelines to simplify the development of service‐oriented applications and services. EasySOC is a synthesized catalog of best SOC development practices that arise as a result of several years of research in fundamental Services Computing topics, that is, Web Service Description Language‐based technical specification, Web Service discovery, and Web Service outsourcing. In addition, we describe a materialization of the guidelines for the Java language, which has been implemented as a plug‐in for the Eclipse IDE. We believe that both the practical nature of the guidelines and the availability of this software that enforces them may help software practitioners to rapidly exploit our ideas for building real SOC applications. Copyright © 2012 John Wiley & Sons, Ltd.

The EasySOC Project: A Rich Catalog of Best Practices for Developing Web Service Applications∗


 
 
 The Service-Oriented Computing (SOC) paradigm has gained a lot of attention in the software in- dustry since SOC represents a novel way of architecting distributed applications. SOC is mostly materialized via Web Services, which allow developers to expose their application as building blocks for other applications by defining a clear and public interface. Although conceptually and technologically mature, SOC still lacks adequate development support from a methodological point of view. We present the EasySOC project: a catalog of guidelines to build service-oriented applications and services. This catalog synthesizes best SOC development practices that arise as a result of several years of research in fundamental SOC-related topics, namely WSDL-based technical specification, Web Service discovery and Web Service outsourcing. In addition, we describe a plug-in for the Eclipse IDE that has been implemented to simplify the utilization of the guidelines. We believe that the practical nature of the guidelines, the empirical evidence that supports them, and the availability of IDE-integrated tools that enforces them will help software practitioners to rapidly exploit our ideas for building real SOC applications.
 
 

A Heuristic Method for Learning Path Sequencing for Intelligent Tutoring System (ITS) in E-learning

Course sequencing is one of the vital aspects in an Intelligent Tutoring System (ITS) for e-learning to generate the dynamic and individual learning path for each learner. Many researchers used different methods like Genetic Algorithm, Artificial Neural Network, and TF-IDF (Term Frequency- Inverse Document Frequency) in E-leaning systems to find the adaptive course sequencing by obtaining the relation between the courseware. In this paper, heuristic semantic values are assigned to the keywords in the courseware based on the importance of the keyword. These values are used to find the relationship between courseware based on the different semantic values in them. The dynamic learning path sequencing is then generated. A comparison is made in two other important methods of course sequencing using TF-IDF and Vector Space Model (VSM) respectively, the method produces more or less same sequencing path in comparison to the two other methods. This method has been implemented using Eclipse IDE for java programming, MySQL as database, and Tomcat as web server.

A Controlled Experiment for Program Comprehension through Trace Visualization

Software maintenance activities require a sufficient level of understanding of the software at hand that unfortunately is not always readily available. Execution trace visualization is a common approach in gaining this understanding, and among our own efforts in this context is Extravis, a tool for the visualization of large traces. While many such tools have been evaluated through case studies, there have been no quantitative evaluations to the present day. This paper reports on the first controlled experiment to quantitatively measure the added value of trace visualization for program comprehension. We designed eight typical tasks aimed at gaining an understanding of a representative subject system, and measured how a control group (using the Eclipse IDE) and an experimental group (using both Eclipse and Extravis) performed these tasks in terms of time spent and solution correctness. The results are statistically significant in both regards, showing a 22 percent decrease in time requirements and a 43 percent increase in correctness for the group using trace visualization.

The spoofax language workbench

Spoofax is a language workbench for efficient, agile development of textual domain-specific languages with state-of-the-art IDE support. Spoofax integrates language processing techniques for parser generation, meta-programming, and IDE development into a single environment. It uses concise, declarative specifications for languages and IDE services. In this paper we describe the architecture of Spoofax and introduce idioms for high-level specifications of language semantics using rewrite rules, showing how analyses can be reused for transformations, code generation, and editor services such as error marking, reference resolving, and content completion. The implementation of these services is supported by language-parametric editor service classes that can be dynamically loaded by the Eclipse IDE, allowing new languages to be developed and used side-by-side in the same Eclipse environment.

A Family of Tools for Supporting the Learning of Programming

Both learning how to program and understanding algorithms or data structures are often difficult. This paper presents three complementary approaches that we employ to help our students in learning to program, especially during the first term of their study. We use a web-based programming task database as an easy and risk-free environment for taking the first steps in programming Java. The Animal algorithm visualization system is used to visualize the dynamic behavior of algorithms and data structures. We complement both approaches with tutorial videos on using the Eclipse IDE. We also report on the experiences with this combined approach.

Context Aware Mobile Service Deployment Model of Agricultural Information System for Indian Farmers

The objective of the paper is to propose a context aware mobile service deployment model to deliver the needed information to the farmers in planning their agricultural activities. The application developed based on this model utilizes the GSM networking of mobile devices to bring the details to the farmers using location awareness features. A context aware service deployment model for information retrieval is achieved and the various contexts can be updated in the mobile servers. The information regarding the agriculture like nature of fertile lands, healthy seeds, proportion of fertilizers and pesticides are made available to the farmers that will enable them to take correct decisions in their pre and post harvesting activities. Since the literacy rate of farmers is low in developing countries, a special GSM device is emulated so as to reduce the number of interactions between the farmers and the services through visual buttons only. The emulated GSM based mobile phone with only a few specific buttons for the fundamental information like soil details, healthy seeds, favorable climatic conditions and suitable harvesting period. This information is made available to them at reasonable cost without heavily forcing them to interact with the agricultural experts. The model is implemented using J2ME using Eclipse IDE with HTTP server.

Composable thread coloring

This paper introduces the language-independent concept of ``thread usage policy.'' Many multi-threaded software systems contain policies that regulate associations among threads, executable code, and potentially shared state. A system, for example, may constrain which threads are permitted to execute particular code segments, usually as a means to constrain those threads from accessing or writing particular elements of state. These policies ensure properties such as state confinement or reader/writer constraints, often without recourse to locking or transaction discipline. Our approach allows developers to concisely document their thread usage policies in a manner that enables the use of sound scalable analysis to assess consistency of policy and as-written code. This paper identifies the key semantic concepts of our thread coloring language and illustrates how to use its succinct source-level annotations to express models of thread usage policies, following established annotation conventions for Java. We have built a prototype static analysis tool, implemented as an integrated development environment plug-in (for the Eclipse IDE), that notifies developers of discrepancies between policy annotations and as-written code. Our analysis technique uses several underlying algorithms based on abstract interpretation, call-graphs, and type inference. The resulting overall analysis is both sound and composable. We have used this prototype analysis tool in case studies to model and analyze more than a million lines of code. Our validation process included field trials on a wide variety of complex large-scale production code selected by the host organizations. Our in-field experience led us to focus on potential adoptability by real-world developers. We have developed techniques that can reduce annotation density to less than one line per thousand lines of code (KLOC). In addition, the prototype analysis tool supports an incremental and iterative approach to modeling and analysis. This approach enabled field trial partners to directly target areas of greatest concern and to achieve useful results within a few hours.

Energy and Power Consumption Estimation for Embedded Applications and Operating Systems

This paper presents a methodology that permits to estimate the power and energy consumption of embedded applications. Estimation is performed from high-level specifications of the complete system. Power models are built from physical measurements on the hardware platform. Operating system’s services are modeled: scheduler/timer interrupt, inter-process communications, devices accesses models are presented. The operating system’s energy overhead is expressed as the sum of multiple contributions related to services activated during a run. Our methodology is applied to the modeling of a Xillinx Virtex-II Pro XUP platform, and a Linux 2.6 operating system. The comparison of consumption estimations and measurements for different versions of a multi-threaded MJPEG application shows an error ranging from 1% to 11%. Our methodology and power models have been integrated in a CAD tool, named CAT (Consumption Analysis Toolbox), deployed in the Eclipse IDE and also included in the Open Source AADL Tool Environment, bringing energy estimation capabilities in the AADL design flow.

Towards automatic software model checking of thousands of Linux modules—a case study with Avinux

AbstractModular software model checking of large real‐world systems is known to require extensive manual effort in environment modelling and preparing source code for model checking. Avinux is a tool chain that facilitates the automatic analysis of Linux and especially of Linux device drivers. The tool chain is implemented as a plugin for the Eclipse IDE, using the source code bounded model checker CBMC as its backend. Avinux supports a verification process for Linux that is built upon specification annotations with SLICx (an extension of the SLIC language), automatic data environment creation, source code transformation and simplification, and the invocation of the verification backend. In this paper technical details of the verification process are presented: Using Avinux on thousands of drivers from various Linux versions led to the discovery of six new errors. In these experiments, Avinux also reduced the immense overhead of manual code preprocessing that other projects incurred. Copyright © 2008 John Wiley & Sons, Ltd.

AVal: an extensible attribute‐oriented programming validator for Java

AbstractAttribute‐oriented programming (@OP) permits programmers to extend the semantics of a base program by annotating it with attributes defined in an attribute domain‐specific language (AttDSL). In this article, we propose AVal: a Java5 framework for the definition and checking of rules for @OP in Java. We define a set of meta‐annotations to allow the validation of @OP programs, as well as the means to extend these meta‐annotations by using a compile‐time model of the program's source code. AVal is fully integrated into the Eclipse IDE. We show the usefulness of the approach by using examples of its use applied to three AttDSLs: an @OP framework that helps programming Simple API for XML parsers, an @OP extension for the Fractal component model called Fraclet, and the JSR 181 for web services definition. Copyright © 2007 John Wiley & Sons, Ltd.

Cyclone: java-based querying and computing with Pathway/Genome databases

Cyclone aims at facilitating the use of BioCyc, a collection of Pathway/Genome Databases (PGDBs). Cyclone provides a fully extensible Java Object API to analyze and visualize these data. Cyclone can read and write PGDBs, and can write its own data in the CycloneML format. This format is automatically generated from the BioCyc ontology by Cyclone itself, ensuring continued compatibility. Cyclone objects can also be stored in a relational database CycloneDB. Queries can be written in SQL, and in an intuitive and concise object-oriented query language, Hibernate Query Language (HQL). In addition, Cyclone interfaces easily with Java software including the Eclipse IDE for HQL edition, the Jung API for graph algorithms or Cytoscape for graph visualization. Cyclone is freely available under an open source license at: http://sourceforge.net/projects/nemo-cyclone. For download and installation instructions, tutorials, use cases and examples, see http://nemo-cyclone.sourceforge.net.

Visual support of software engineers during development and maintenance

Software systems have reached a level of complexity that puts them beyond our ability to evolve and maintain them easily. This increases the need for soft-ware organizations to develop new or rework existing systems with high quality. CodeSonar was developed to support software engineers during software development and maintenance activities through the visualization of source code and quality defects using a visual interface in the eclipse IDE. A first qualitative evaluation indicates that it helps the user in navigating in the software system.

A design-first curriculum and Eclipse™ tools

This tutorial introduces a curriculum and tools supporting a design-first pedagogy for teaching object-oriented programming in a CS1 course (Moritz and Blank 2005, Moritz et al. 2005). Design-first emphasizes the big picture of software development---how to understand and solve a customer's problem, rather than just coding. The design-first approach subsumes objects-first---instead of a Hello, World program, in the first lesson students learn how to use classes, constructors and methods to create scenes out of graphical objects. They also quickly learn how to develop use cases to analyze a customer's problem, and then how to design class diagrams in Unified Modeling Language (UML). Interactive multimedia courseware helps introduce these concepts (Blank et al. 2003). Students learn how to manipulate objects using the open-source Eclipse IDE with the DrJava interactive interpreter plug-in. They design class diagrams in the LehighUML plug-in, which automatically generates skeletons of Java source code. The LehighUML plug-in also sends each step of student work to a server, where an intelligent tutoring system analyzes their work and provides hints and lessons (Blank et al. 2005 and Wei et al. 2005).