SCG News

Exploring Cheap Type Inference Heuristics in Dynamically Typed Languages

Nevena Milojković and Oscar Nierstrasz. Exploring Cheap Type Inference Heuristics in Dynamically Typed Languages. In Proceedings of the 2016 ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software, Onward! 2016, p. 43—56, ACM, New York, NY, USA, 2016. Details.


Although dynamically typed languages allow developers to be more productive in writing source code, their lack of information about types of variables is one of the main obstacles during program comprehension. Static type information helps developers to decrease software maintenance time. Inferring the types of variables requires complex algorithms in order to avoid false positives or negatives. Their main aim is to shorten the list of possible types for a variable. We have developed a couple of cheap heuristics that use easily accessible information about the presence of each class in the available source code to promote the correct type towards the top of the list of possible types for a variable. Our evaluation of a proof-of-concept prototype, implemented in Pharo Smalltalk, shows that both for domain- specific types and standard libraries these heuristics tend to work well. The evaluated heuristics prove to be reasonably precise, promoting the correct types of a variable towards the top of the list in 50.67% up to 89.09% of cases on average, depending on the applied heuristic. The heuristic that has proven to be the best was compared with one existing type inference algorithm and the best heuristic yields significantly better results with less effort.

Posted by scg at 1 December 2016, 10:15 am comment link

Engineering Academic Software (Dagstuhl Perspectives Workshop 16252)

Carol Goble, James Howison, Claude Kirchner, Oscar Nierstrasz, and Jurgen J. Vinju. Engineering Academic Software (Dagstuhl Perspectives Workshop 16252). In Dagstuhl Reports 6(6) p. 62—87, 2016. Details.


This report documents the program and the outcomes of Dagstuhl Perspectives Workshop 16252 “Engineering Academic Software”.

Posted by scg at 18 November 2016, 10:15 am comment link

Parsing For Agile Modeling

Jan Kurš. Parsing For Agile Modeling. PhD thesis, University of Bern, October 2016. Details.


Agile modeling refers to a set of methods that allow for a quick initial development of an importer and its further refinement. These requirements are not met simultaneously by the current parsing technology. Problems with parsing became a bottleneck in our research of agile modeling. In this thesis we introduce a novel approach to specify and build parsers. Our approach allows for expressive, tolerant and composable parsers without sacrificing performance. The approach is based on a context-sensitive extension of parsing expression grammars that allows a grammar engineer to specify complex language restrictions. To insure high parsing performance we automatically analyze a grammar definition and choose different parsing strategies for different parts of the grammar. We show that context-sensitive parsing expression grammars allow for highly composable, tolerant and variable-grained parsers that can be easily refined. Different parsing strategies significantly insure high-performance of parsers without sacrificing expressiveness of the underlying grammars.

Posted by scg at 8 November 2016, 10:15 am comment link

Against the Mainstream in Bug Prediction

Haidar Osman. Against the Mainstream in Bug Prediction. In Extended Abstracts of the Ninth Seminar on Advanced Techniques and Tools for Software Evolution (SATToSE 2016), July 2016. Details.


Bug prediction is a technique used to estimate the most bug-prone entities in software systems. Bug prediction approaches vary in many design options, such as dependent variables, independent variables, and machine learning models. Choosing the right combination of design options to build an effective bug predictor is hard. Previous studies do not consider this complexity and draw conclusions based on fewer-than-necessary experiments. We argue that each software project is unique from the perspective of its development process. Consequently, metrics and AI models perform differently on different projects, in the context of bug prediction. We confirm our hypothesis empirically by running different bug pre- dictors on different systems. We show that no single bug prediction configuration works globally on all projects and, thus, previous bug prediction findings cannot generalize.

Posted by scg at 18 October 2016, 5:15 pm comment link

Moldable Tools

Andrei Chiş. Moldable Tools. PhD thesis, University of Bern, September 2016. Details.


Development tools are a prerequisite for crafting software. They offer the lenses through which developers perceive and reason about their software systems. Generic development tools, while having a wide range of applicability, ignore the contextual nature of software systems and do not allow developers to directly reason in terms of domain abstractions. Domain-specific development tools, tailored to particular application domains, can address this problem. While it has clear advantages, incorporating domain abstractions into development tools is a challenging activity. The wide range of domains and contextual tasks that development tools need to support leads to costly or ad hoc mechanisms to incorporate and discover domain abstractions. Inherently, this limits developers from taking advantage of domain-specific information during the development and maintenance of their systems. To overcome this problem, we propose to embed domain abstractions into development tools through the design of moldable tools that support the inexpensive creation of domain-specific extensions capturing domain abstractions, and that automatically select extensions based on the domain model and the developer’s interaction with the domain model. This solution aims to reduce the cost of creating extensions. Towards this goal, it provides precise extension points together with internal DSLs for configuring common types of extensions. This solution facilitates automatic discovery by enabling extension creators to specify together with an extension an activation predicate that captures the context in which that extension is applicable. We validate the moldable tools approach by applying it, in the context of object-oriented applications, to improve three development activities, namely: reasoning about run-time objects, searching for domain-specific artifacts, and reasoning about run-time behavior. For each activity we identify limitations of current tools, show how redesigning those tools following the moldable tools approach addresses the identified limitations, and discuss the cost for creating domain-specific extensions. We demonstrate that moldable tools address an existing need by analyzing the increase in domain-specific extensions after we integrated the moldable tools solving the aforementioned tasks with an IDE. We also show what kinds of custom environments developers can create by continuously adapting their development tools.

Posted by scg at 2 October 2016, 11:15 pm comment link
<< 1 2 3 4 5 6 7 8 9 10 >>
Last changed by scg on 17 August 2016