4,331 research outputs found
RuntimeSearch: Ctrl+F for a Running Program
Developers often try to find occurrences of a certain term in a software
system. Traditionally, a text search is limited to static source code files. In
this paper, we introduce a simple approach, RuntimeSearch, where the given term
is searched in the values of all string expressions in a running program. When
a match is found, the program is paused and its runtime properties can be
explored with a traditional debugger. The feasibility and usefulness of
RuntimeSearch is demonstrated on a medium-sized Java project
SPEEDY: An Eclipse-based IDE for invariant inference
SPEEDY is an Eclipse-based IDE for exploring techniques that assist users in
generating correct specifications, particularly including invariant inference
algorithms and tools. It integrates with several back-end tools that propose
invariants and will incorporate published algorithms for inferring object and
loop invariants. Though the architecture is language-neutral, current SPEEDY
targets C programs. Building and using SPEEDY has confirmed earlier experience
demonstrating the importance of showing and editing specifications in the IDEs
that developers customarily use, automating as much of the production and
checking of specifications as possible, and showing counterexample information
directly in the source code editing environment. As in previous work,
automation of specification checking is provided by back-end SMT solvers.
However, reducing the effort demanded of software developers using formal
methods also requires a GUI design that guides users in writing, reviewing, and
correcting specifications and automates specification inference.Comment: In Proceedings F-IDE 2014, arXiv:1404.578
Live Multi-language Development and Runtime Environments
Context: Software development tools should work and behave consistently
across different programming languages, so that developers do not have to
familiarize themselves with new tooling for new languages. Also, being able to
combine multiple programming languages in a program increases reusability, as
developers do not have to recreate software frameworks and libraries in the
language they develop in and can reuse existing software instead.
Inquiry: However, developers often have a broad choice of tools, some of
which are designed for only one specific programming language. Various
Integrated Development Environments have support for multiple languages, but
are usually unable to provide a consistent programming experience due to
different language-specific runtime features. With regard to language
integrations, common mechanisms usually use abstraction layers, such as the
operating system or a network connection, which are often boundaries for tools
and hence negatively affect the programming experience.
Approach: In this paper, we present a novel approach for tool reuse that aims
to improve the experience with regard to working with multiple high-level
dynamic, object-oriented programming languages. As part of this, we build a
multi-language virtual execution environment and reuse Smalltalk's live
programming tools for other languages.
Knowledge: An important part of our approach is to retrofit and align runtime
capabilities for different languages as it is a requirement for providing
consistent tools. Furthermore, it provides convenient means to reuse and even
mix software libraries and frameworks written in different languages without
breaking tool support.
Grounding: The prototype system Squimera is an implementation of our approach
and demonstrates that it is possible to reuse both development tools from a
live programming system to improve the development experience as well as
software artifacts from different languages to increase productivity.
Importance: In the domain of polyglot programming systems, most research has
focused on the integration of different languages and corresponding performance
optimizations. Our work, on the other hand, focuses on tooling and the overall
programming experience
Integrating Runtime Values with Source Code to Facilitate Program Comprehension
An inherently abstract nature of source code makes programs difficult to
understand. In our research, we designed three techniques utilizing concrete
values of variables and other expressions during program execution.
RuntimeSearch is a debugger extension searching for a given string in all
expressions at runtime. DynamiDoc generates documentation sentences containing
examples of arguments, return values and state changes. RuntimeSamp augments
source code lines in the IDE (integrated development environment) with sample
variable values. In this post-doctoral article, we briefly describe these three
approaches and related motivational studies, surveys and evaluations. We also
reflect on the PhD study, providing advice for current students. Finally,
short-term and long-term future work is described
A web-based IDE for IDP
IDP is a knowledge base system based on first order logic. It is finding its
way to a larger public but is still facing practical challenges. Adoption of
new languages requires a newcomer-friendly way for users to interact with it.
Both an online presence to try to convince potential users to download the
system and offline availability to develop larger applications are essential.
We developed an IDE which can serve both purposes through the use of web
technology. It enables us to provide the user with a modern IDE with relatively
little effort.Comment: International Workshop on User-Oriented Logic Programming (IULP
2015), co-located with the 31st International Conference on Logic Programming
(ICLP 2015), Proceedings of the International Workshop on User-Oriented Logic
Programming (IULP 2015), Editors: Stefan Ellmauthaler and Claudia Schulz,
pages 21-32, August 201
Visual augmentation of source code editors: A systematic mapping study
Source code written in textual programming languages is typically edited in
integrated development environments or specialized code editors. These tools
often display various visual items, such as icons, color highlights or more
advanced graphical overlays directly in the main editable source code view. We
call such visualizations source code editor augmentation.
In this paper, we present a first systematic mapping study of source code
editor augmentation tools and approaches. We manually reviewed the metadata of
5,553 articles published during the last twenty years in two phases -- keyword
search and references search. The result is a list of 103 relevant articles and
a taxonomy of source code editor augmentation tools with seven dimensions,
which we used to categorize the resulting list of the surveyed articles.
We also provide the definition of the term source code editor augmentation,
along with a brief overview of historical development and augmentations
available in current industrial IDEs
Navigate, Understand, Communicate: How Developers Locate Performance Bugs
Background: Performance bugs can lead to severe issues regarding computation
efficiency, power consumption, and user experience. Locating these bugs is a
difficult task because developers have to judge for every costly operation
whether runtime is consumed necessarily or unnecessarily. Objective: We wanted
to investigate how developers, when locating performance bugs, navigate through
the code, understand the program, and communicate the detected issues. Method:
We performed a qualitative user study observing twelve developers trying to fix
documented performance bugs in two open source projects. The developers worked
with a profiling and analysis tool that visually depicts runtime information in
a list representation and embedded into the source code view. Results: We
identified typical navigation strategies developers used for pinpointing the
bug, for instance, following method calls based on runtime consumption. The
integration of visualization and code helped developers to understand the bug.
Sketches visualizing data structures and algorithms turned out to be valuable
for externalizing and communicating the comprehension process for complex bugs.
Conclusion: Fixing a performance bug is a code comprehension and navigation
problem. Flexible navigation features based on executed methods and a close
integration of source code and performance information support the process.Comment: 10 pages, 7 figures, Proceedings of the 2015 ACM/IEEE International
Symposium on Empirical Software Engineering and Measurement (ESEM 2015),
IEEE, 2015, pp. 225-23
LoIDE: a web-based IDE for Logic Programming - Preliminary Technical Report
Logic-based paradigms are nowadays widely used in many different fields, also
thank to the availability of robust tools and systems that allow the
development of real-world and industrial applications.
In this work we present LoIDE, an advanced and modular web-editor for
logic-based languages that also integrates with state-of-the-art solvers.Comment: 11 pages, 3 figure
Eclipse-IT 2013: Proceedings of VIII Workshop of the Italian Eclipse Community
This volume contains the extended abstracts of the contributions presented at
EclipseIT 2013, the 8th workshop of the Italian Eclipse Community, hosted by
the Computer Science Department of the University of Milan (Crema Campus) on
September 19-20, 2013. Although Eclipse was initially designed as an integrated
development environment (IDE) for object-oriented application development,
today it represents an open development platform comprised of extensible
frameworks, tools and runtimes for building, deploying and managing software.
Around Eclipse, an international live community continuously works on improving
the framework and on promoting the use of Eclipse. That happens also in Italy.
This workshop is, indeed, the eighth yearly meeting of the Italian Eclipse
Community which includes universities, public institutions and industries,
researchers and practitioners, students and professionals, all joined by the
interest in experimenting, extending, and supporting the Eclipse platform. The
special topic of this edition is the Software cooperative development for
mobile applications. Two tutorials are offered on this theme: (1) Sviluppo di
applicazioni enterprise per il mobile con IBM Jazz, Eclipse e Worklight by
Ferdinando Gorga from IBM, and (2) Uso di Eclipse per lo sviluppo cooperativo
del software, by Paolo Maresca of the University of Naples, Federico II.Comment: conference eclipse it 2013 - Crema 19-20 September 2013 - ISBN:
978-88-904388-4-
A New Students Development Board for Embedded Systems
This article describes a new development board for embedded system that was designed especially for Microcontroller and microprocessors student course. Not only hardware part was created, but also compiler, IDE and JTAG probe were selected. And of course, some examples were prepared
- …