Refine
Year of publication
- 2017 (5) (remove)
Document Type
- Article (2)
- Monograph/Edited Volume (2)
- Doctoral Thesis (1)
Language
- English (5)
Is part of the Bibliography
- yes (5)
Keywords
- Abhängigkeiten (1)
- ContextErlang (1)
- Debugging (1)
- Distributed debugging (1)
- Dynamic analysis (1)
- Interpreter (1)
- Programmiererlebnis (1)
- Python (1)
- Record and refinement (1)
- Record and replay (1)
- Ruby (1)
- Smalltalk (1)
- Softwarearchitektur (1)
- Softwaretests (1)
- Travis CI (1)
- Visualisierung (1)
- active layers (1)
- context groups (1)
- contextual-variability modeling (1)
- continuous integration (1)
- continuous testing (1)
- debugging (1)
- dependencies (1)
- entity-component-system (1)
- group-based behavior adaptation (1)
- implied methods (1)
- integrated development environments (1)
- integrierte Entwicklungsumgebungen (1)
- interpreters (1)
- kontinuierliche Integration (1)
- kontinuierliches Testen (1)
- lively groups (1)
- mehrsprachige Ausführungsumgebungen (1)
- object-oriented languages (1)
- periodic tasks (1)
- periodische Aufgaben (1)
- polyglot execution environments (1)
- predicated generic functions (1)
- programming experience (1)
- reactive object queries (1)
- small talk (1)
- software architecture (1)
- software development (1)
- software engineering (1)
- software tests (1)
- visualization (1)
Distributed applications are hard to debug because timing-dependent network communication is a source of non-deterministic behavior. Current approaches to debug non deterministic failures include post-mortem debugging as well as record and replay. However, the first impairs system performance to gather data, whereas the latter requires developers to understand the timing-dependent communication at a lower level of abstraction than they develop at. Furthermore, both approaches require intrusive core library modifications to gather data from live systems. In this paper, we present the Peek-At-Talk debugger for investigating non-deterministic failures with low overhead in a systematic, top-down method, with a particular focus on tool-building issues in the following areas: First, we show how our debugging framework Path Tools guides developers from failures to their root causes and gathers run-time data with low overhead. Second, we present Peek-At-Talk, an extension to our Path Tools framework to record non-deterministic communication and refine behavioral data that connects source code with network events. Finally, we scope changes to the core library to record network communication without impacting other network applications.
Squimera
(2017)
Software development tools that work and behave consistently across different programming languages are helpful for developers, because they do not have to familiarize themselves with new tooling whenever they decide to use a new language. 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.
However, developers often have a broad choice with regard to 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 features of language runtimes. Furthermore, common mechanisms that allow reuse of software written in other languages usually use the operating system or a network connection as the abstract layer. Tools, however, often cannot support such indirections well and are therefore less useful in debugging scenarios for example.
In this report, we present a novel approach that aims to improve the programming experience with regard to working with multiple high-level programming languages. As part of this approach, we reuse the tools of a Smalltalk programming environment for other languages and build a multi-language virtual execution environment which is able to provide the same runtime capabilities for all languages.
The prototype system Squimera is an implementation of our approach and demonstrates that it is possible to reuse development tools, so that they behave in the same way across all supported programming languages. In addition, it provides convenient means to reuse and even mix software libraries and frameworks written in different languages without breaking the debugging experience.
Developing large software projects is a complicated task and can be demanding for developers. Continuous integration is common practice for reducing complexity. By integrating and testing changes often, changesets are kept small and therefore easily comprehensible. Travis CI is a service that offers continuous integration and continuous deployment in the cloud. Software projects are build, tested, and deployed using the Travis CI infrastructure without interrupting the development process. This report describes how Travis CI works, presents how time-driven, periodic building is implemented as well as how CI data visualization can be done, and proposes a way of dealing with dependency problems.