Nowadays, Android is by far the most popular operating system on a myriad of mobile devices. Although based on the Java programming language, Android does not offer the same benefits as a dynamic software module system such as OSGi. Nevertheless OSGi would have many advantages on mobile environments. Software modularity allows you to only deploy the required pieces of software at runtime. Moreover, many of the enterprise OSGi specifications facilitate the development of distributed applications connecting to the Cloud. In order to exploit these advantages on Android, we present Androsgi, an Eclipse IDE plugin that allows you to easily run OSGi on top of Android. The Androsgi plugin facilitates deploying OSGi bundles, and calling both local and remote OSGi services from within your Android application.
Software Product Line Engineering (SPLE) is a systematic approach for the development of related software products. These products share a common infrastructure but vary with respect to their individual capabilities, called variabilities. Variability management is a key part of SPLE and is responsible for developing, combining and configuring such variabilities. As these activities are inherently complex, SPLE significantly benefits from tool-support. We developed a customizable Eclipse extension for SPLE that consists of around 38 plug-ins. The resulting tool, called EASy-Producer, extends the Eclipse IDE by the capability to support the creation and management of software product line projects. To provide this capability, EASy-Producer utilizes the extension concepts of the Eclipse platform and integrates additional frameworks, like Xtext. In this paper, we share our experience while applying the Eclipse technologies and, in particular, realizing specific capabilities of our tool using the Eclipse framework. The focus of this paper is on our lessons learned regarding managing workspace information and conflicting build mechanism as well as using Eclipse extensions outside of Eclipse. These lessons serve as an input to the Eclipse community and may help other developers in realizing a complex Eclipse extension.
GOLD (Graph Oriented Language) is a general purpose programming language with mathematical notations and a pseudocode-like syntax for defining and manipulating graphs and other high-level data structures such as sets, trees, and automata. Its syntax was inspired by the one used in classic algorithms textbooks. It allows set comprehensions, quantified expressions, and new control instructions. Its syntax also supports the use of Java defined classes. GOLD programs are translated into Java. Therefore, Java programs can use functions, procedures, and objects defined in GOLD. GOLD was developed as a whole new programming environment for programming and testing algorithms for advanced data structures. All GOLD components were packed into an Eclipse plug-in coded in Java under the Xtext framework. GOLD’s design and implementation can be seen as a case study in language development.
Debugging is difficult and costly, especially for failures that occur after deployment. In prior work, we developed a suite of instrumentation and analysis tools, collectively titled the Crash Scene Investigation toolkit (CSI). These tools aid developers by providing additional information about failing program executions using latent data in post-failure memory dumps. While we showed that our technique is effective in reducing execution ambiguity, it lacked a proper user interface for developers. In this paper, we present CSIclipse, a work-in-progress plugin for the Eclipse integrated development environment (IDE) that brings our analyses directly to the user. The goal of our plugin is to ease the burden of debugging production failures by conveniently presenting CSI trace and analysis data with intuitive source code overlays and powerful data exploration mechanisms. While designed for our CSI data, our plugin is likely general enough to support trace data from a variety of program analyses.
One of the most common security & privacy issues concerning mobile applications is the unnecessary access to sensitive information and resources. In a mobile application platform like Android, where a permission mechanism is used to maintain access control, the app developer dictates what permissions are necessary at install time. For various reasons however, including user confusion and lack of proper documentation, developers may overcompensate for the necessary permission. By this we mean developers often incorporate more permissions than are necessary for an app to function, thus undermining the access control mechanism and increasing the potential risk from a vulnerability exploit where sensitive user information is compromised. Even when developers intentionally include extra permissions, we believe it still the duty of a developer to at least be aware of what is at stake when it comes to collecting user information. In this paper we present PermitMe, a tool developed as a plugin for the Eclipse IDE, to interactively guide developers on the set of required permissions when creating Android applications. We conducted a between-groups user study in order to evaluate the effectiveness, efficiency, and usability of the PermitMe tool in enhancing the developer's experience when deciding to include Android permissions in their mobile applications.
In this industrial presentation we will demonstrate mbeddr, an extensible set of integrated languages for embedded software development. After discussing the context of the talk, we will give details about the mbeddr architecture, which relies on the MPS language workbench. Then we will elaborate on the extension modules and show how they fit with safety-critical development processes. Finally we will point out how the existing languages can be extended by the user by giving some real-world examples, including a language construct that could have prevented the Apple 'goto fail' bug as well as mathematical notations.
We propose a novel Eclipse Perspective, the Runtime Perspective, that makes a global hierarchy of abstract objects a first-class view of an object-oriented system at design-time. The perspective includes many views that complement the existing views in the Java Development perspective: an Abstract Object Tree with a search feature to complement the Package Explorer, an Abstract Stack to complement the Call Hierarchy, and a Partial Object Graph, to complement the class diagrams extracted by many existing plugins.
Many novice software developers do not have the training, experience or appropriate resources in developing privacy policies for their applications. Anecdotal evidence suggests that some new software developers create original, natural language privacy policies, use existing privacy policies as templates or an external agency (i.e., a legal counsel). This paper presents an overview of the privacy Policy Auto-Generation in Eclipse (PAGE), a work-in-progress that seeks to integrate privacy planning capabilities into the Eclipse integrated development environment (IDE), enabling application developers to create privacy policies as development occurs. This should support privacy by design concepts, enhance team communication through reusability, as well as reduce costs due to errors or extra time in external activities.
ABSTRACTCloud Application Management for Platforms (CAMP) is a standard that addresses the problem of portability of artifacts and interoperability of APIs in a Platform as a Service (PaaS) environment. It defines the artifacts and APIs that need to be offered by a PaaS to manage building, running, administering, monitoring and patching of applications in the cloud. This is a collaborative open standard that is being developed in OASIS. One of the goals for this effort is to allow developers, users, and vendors to create tools and services that interact with any conforming PaaS. The interoperability between platform clouds that CAMP offers means that a CAMP client such as an Integrated Development Environment (IDE) can target multiple clouds with a single common interface/implementation. In addition to various vendors, OpenStack Solum and Apache Brooklyn have both adopted CAMP and it is central to their design.
The information in bug reports influences the speed at which bugs are fixed. However, bug reports differ in their quality of information. We conducted a survey among ECLIPSE developers to determine the information in reports that they widely used and the problems frequently encountered. Our results show that steps to reproduce and stack traces are most sought after by developers, while inaccurate steps to reproduce and incomplete information pose the largest hurdles. Surprisingly, developers are indifferent to bug duplicates. Such insight is useful to design new bug tracking tools that guide reporters at providing more helpful information. We also present a prototype of a quality-meter tool that measures the quality of bug reports by scanning its content.
We present a declarative and visual debugging environment for Eclipse called JIVE.1 Traditional debugging is procedural in that a programmer must proceed step-by-step and object-by-object in order to uncover the cause of an error. In contrast, we present a declarative approach to debugging consisting of a flexible set of queries over a program's execution history as well as over individual runtime states. This runtime information is depicted in a visual manner during program execution in order to aid the debugging process. The current state of execution is depicted through an enhanced object diagram, and the history of execution is depicted by a sequence diagram. Our methodology makes use of these diagrams as a means of formulating queries and reporting results in a visual manner. It also supports revisiting past runtime states, either through reverse stepping of the program or through queries that report information from past states. Eclipse serves as an ideal framework for implementing JIVE since, like the JIVE architecture, it makes crucial use of the Java Platform Debugging Architecture (JPDA). This paper presents details of the JIVE architecture and its integration into Eclipse.
eConference is a text-based conferencing tool that supports distributed teams in need for synchronous communication and structured discussion services. Other than offering communication services, it integrates an agenda and minutes editor, plus other control and coordination features, like hand raising and threaded discussion. The current version of the tool is based on Eclipse RCP and uses the eXtensible Messaging and Presence Protocol (XMPP) as the only communication infrastructure. The goal of this paper is presenting a work-in-progress to port the eConference tool on the Eclipse Communication Framework (ECF), which will enables us to abstract from the underlying communication protocol, provide better decoupling among components, and build additional team-support services.
Although the Eclipse IDE offers an extremely useful built-in support for developing Eclipse plug-ins, it lacks the ability to perform dynamic updates of plug-ins in a running instance of the application being developed. Because of the nature of the Eclipse architecture and its strict class-loader delegation, plug-ins can only communicate through well-defined APIs. By applying a novel dynamic update approach to the eclipse plug-in development environment that exploits this knowledge, a new API are defined, namely the Dynamic API. This paper discusses some of the ordinary binary compatible changes that lead to erroneous program behaviour if not properly handled. Furthermore, it discusses how applying a dynamic update approach at development time gives developers a unique chance to experiment with dynamic updates without risking a costly shutdown of a real-life application.
Software development involves the use of many models and Eclipse provides an ideal infrastructure for building tools to support the use of models. While there is a large selection of tools available for working with individual models, there is less support for working with collections of models, as for example, when a collection of models from different sources must be merged. We have identified the problem of working with collections of related models in software development as the Software Model Management (SMM) problem - a close cousin of the Model Management problem in the area of metadata management. In the course of building SMM tools to address particular scenarios, we have observed that they share common foundations both at the theoretical and implementation levels. In this paper, we describe the vision and initial development of a framework that implements these common foundations in order to facilitate and accelerate the development of Eclipse-based SMM tools.
Designing and testing distributed applications is still a difficult task that requires in-depth knowledge about networking issues. Eclipse is, among other things, a powerful and widely used IDE for the development of complex applications, in particular modular applications for the OSGi framework. Our R-OSGi middleware supports the seamless distribution of OSGi applications along the boundaries of services. By combining R-OSGi with Eclipse into the R-OSGi Deployment Tool, we give developers a tool that automatically handles distribution in a transparent way and integrates the capabilities of R-OSGi into the Eclipse workflow. With this tool, building, deploying, and monitoring distributed applications is as easy as writing OSGi applications in Eclipse and using a graphical editor to visually create distributed deployments of the modules. The tool can also be used to great effect by researchers to test and benchmark distributed applications and for education purposes.
In the software development life cycle, unit testing is an important phase that helps in early detection of bugs. A unit test case consists of two parts: a test input, which is often a sequence of method calls, and a test oracle, which is often in the form of assertions. The effectiveness of a unit test case depends on its test input as well as its test oracle because the test oracle helps in exposing bugs during the execution of the test input. The task of writing effective test oracles is not trivial as this task requires domain or application knowledge and also needs knowledge of the intricate details of the class under test. In addition, when developers write new unit test cases, much test code (including code in test inputs or oracles) such as method argument values is the same as some previously written test code. To assist developers in writing test code in unit test cases more efficiently, we have developed an Eclipse plugin for JUnit test cases, called UnitPlus, that runs in the background and recommends test-code pieces for developers to choose (and revise when needed) to put in test oracles or test inputs. The recommendation is based on static analysis of the class under test and already written unit test cases. We have conducted a feasibility study for our UnitPlus plugin with four Java libraries to demonstrate its potential utility.
In evolutionary software development, knowing how design evolves with features can be valuable in guiding future projects. It helps answer questions like "How much upfront design should and can be done?" and "How and why are designs changed?" To shed light on these questions, we report on a study of the evolution history of the Eclipse Java editor. We find that the MVC-based design was cleanly laid out in the beginning of the project and carefully followed and maintained, which has contributed positively to the continuous growth of the editor features. Although design changes at the individual feature level happened for reasons like extensibility and reusability, they appear to be local and manageable. The AST facility is a key service that enables more than one half of the Java editor features.
Programmers often copy and paste code so that they can reuse the existing code to complete a similar task. Many times, modifications to the newly pasted code include renaming all instances of an identifier, such as a variable name, consistently throughout the fragment. When these modifications are done manually, undetected inconsistencies and errors can result in the code, for example, a single instance can be missed and mistakenly not renamed. To help programmers avoid making this type of copy-paste error, we created a tool, named CReN, to provide tracking and identifier renaming support within copy-and-paste clones in an integrated development environment (IDE). CReN tracks the code clones involved when copying and pasting occurs in the IDE and infers a set of rules based on the relationships between the identifiers in these code fragments. These rules capture the programmer's intentions, for example, that a particular group of identifiers should be renamed consistently together. Programmers can also provide feedback to improve the accuracy of the inferred rules by specifying that a particular instance of an identifier is to be renamed separately. We introduce our CReN tool, which is implemented as an Eclipse plug-in in Java.
We present a tool that predicts whether the software under development inside an IDE has a bug. An IDE plugin performs this prediction, using the Change Classification technique to classify source code changes as buggy or clean during the editing session. Change Classification uses Support Vector Machines (SVM), a machine learning classifier algorithm, to classify changes to projects mined from their configuration management repository. This technique, besides being language independent and relatively accurate, can (a) classify a change immediately upon its completion and (b) use features extracted solely from the change delta (added, deleted) and the source code to predict buggy changes. Thus, integrating change classification within an IDE can predict potential bugs in the software as the developer edits the source code, ideally reducing the amount of time spent on fixing bugs later. To this end, we have developed a Change Classification plugin for Eclipse based on client-server architecture, described in this paper.
The navigation of structural dependencies (e.g., method invocations) when a developer performs a change task is an effective strategy in program investigation. Several existing approaches have addressed the problem of finding program elements relevant to a task by using structural dependencies. These approaches provide different levels of benefits: limiting the amount of information returned, providing calling context, and providing global information. Aiming to incorporate these three benefits simultaneously, we propose an approach--called call graph filtering--to help developers narrow down the methods relevant to a change task. Our call graph filtering approach uses heuristics to highlight methods that are likely relevant to a change task on a call graph. The size of the set of relevant methods is reduced by our filtering heuristics, while global information and the calling context are provided by the call graph. We have performed two preliminary studies: a user study on identifying methods relevant to the understanding of JUnit tests on a small system, and an empirical study on how our results can help a developer perform a program navigation task with the Eclipse framework. The studies show that our approach can provide useful results: quantitatively in terms of size of the results, precision, and recall; and qualitatively in terms of finding non-trivial control-flow and being able to direct developer to the code of interest.
