What: On the Naturalness Software: A Research Vision
Who: Earl Barr (University College London)
When: June 20th, 2014, 15:00 – 15:45
Where: Inria Lille, Salle Plénière, http://goo.gl/maps/32z7m

Abstract: Natural languages like French are rich, complex, and powerful. The highly creative and graceful use of languages like French and Tamil, by masters like Flaubert and Avvaiyar, can certainly delight and inspire. But in practice, given cognitive constraints and the exigencies of daily life, most human utterances are far simpler and much more repetitive and predictable. In fact, these utterances can be very usefully modeled using modern statistical methods. This fact has led to the phenomenal success of statistical approaches to speech recognition, natural language translation, question-answering, and text mining and comprehension. Our work rests on the hypothesis that most software is also natural, in the sense that it is created by humans at work, with all the attendant constraints and limitations—and thus, like natural language, it is also likely to be repetitive and predictable. Using the widely adopted n-gram model, we validate this hypothesis and show how one can exploit the local repetitiveness of code to increase programmer productivity using code completion as our motivating example. This work has opened a new avenue of research — the application of large corpus statistical inference directly to code — that has seen much recent activity, including papers at all the top software engineering venues tackling problems as machine translation applied to the code porting problem (ASE), coding convention and idiom inference (FSE), test case generation (ICST), syntactic error localization (MSR), detecting errors in API documentation (OOPSLA), and code synthesis (PLDI).

Biography: Earl Barr is a lecturer at the University College London. He received his Ph.D. (2009) degree in Computer Science at the University of California at Davis. He won the I3P Fellowship from the US Department of Homeland Security in 2010. He is a co-investigator on SemaMatch, a UK EPSRC grant on malware. Dr. Barr’s research interests include testing and program analysis, empirical software engineering, computer security, and distributed systems. His recent work focuses on testing and analysis of numerical software, debugging, malware, obfuscation, and the application of NLP techniques to source code.

What: On the problem statement and evaluation of automatic software repair
Who: Martin Monperrus (University of Lille & Inria)
When: May 28th, 2014, 11:00 – 12:00
Where: Inria Lille, Room B21, http://goo.gl/maps/32z7m

Abstract: At ICSE’2013, there was the first session ever dedicated to automatic program repair. In this session, Kim et al. presented PAR, a novel template-based approach for fixing Java bugs. We strongly disagree with key points of this paper and discuss them in this talk. First, we aim at explaining why we disagree with Kim and colleagues and why the reasons behind this disagreement are important for research on automatic software repair in general. Second, we aim at contributing to the field with a clarification of the essential ideas behind automatic software repair. In particular we discuss the main evaluation criteria of automatic software repair: understandability, correctness and completeness. We show that depending on how one sets up the repair scenario, the evaluation goals may be contradictory.

Who: Laurence Tratt, Software Development Team, King’s College London http://tratt.net/laurie/
Where: B31
When: Thursday, 15th of May, 15h
What: Towards Language Composition

We want better programming languages, but “better” invariably ends up
becoming “bigger”. Since we can’t keep making our languages bigger, what
alternatives do we have? In this talk, I propose language composition as a
possible solution to this long standing problem. Language composition means
merging two languages and allowing them to be used together. At its
most fine-grained, this could allow multiple programming languages to be
used together within a single source file.

However, language composition is not a new idea. It has failed in the past
because editing composed programs was intolerably difficult and the
resulting programs ran too slow to be usable. Without good solutions to
these problems, language composition will remain an unrealised ideal.

In this talk, I will show how the work we are doing in the Software
Development Team is beginning to address both aspects. We have built a
prototype editor utilising a novel concept ‘language boxes’, which allows
one to edit composed programs in a natural way, without the limitations of
traditional approaches. We are tackling the performance problem by
composing together interpreters using meta-tracing, allowing us to build
composed VMs with custom JITs that naturally optimise across different
language’s run-times. While we are much nearer the beginning of the
journey than the end, our initial research has allowed us to build a
simple composition of two very different languages: Python and Prolog.

Joint work with Edd Barrett, Carl Friedrich Bolz, Lukas Diekmann, and
Krishnan Vasudevan. More details at http://soft-dev.org/

What: HDR defense: Supporting Software Evolution in the Organizations
Who: Nicolas Anquetil
When: Friday, May the 09th at 13h30
Where: IRCICA

Abstract:

Software systems are now so intrinsically part of our lives that we don’t see them any more. They run our phones, our cars, our leisures, our banks, our shops, our cities … This brings a significant burden on the software industry. All these systems need to be updated, corrected, and enhanced as the users and consumers have new needs. As a result, most of the software engineering activity may be classified as Software Maintenance, “the totality of activities required to provide cost-effective support to a software system.”
In an ecosystem where processing power for computers, and many other relevant metrics such as disk capacity or network bandwidth, doubles every 18 months (“Moore’s Law”), technologies evolve at a fast pace. In this ecosystem, software maintenance suffers from the drawback of having to address the past (past languages, existing systems, old technologies). It is often ill-perceived, and treated as a punishment. Because of this, solutions and tools for software maintenance have long lagged far behind those for new software development. For example, the antique approach of manually inserting traces in the source code to understand the execution path is still a very valid one.
All my research activity focused on helping people to do software maintenance in better conditions or more efficiently. An holistic approach of the problem must consider the software that has to be maintained, the people doing it, and the organization in which and for which it is done. As such, I studied different facets of the problem that will be presented in three parts in this document: Software: The source code is the center piece of the maintenance activity. Whatever the task (ex: enhancement or bug correction), it typically comes down to understand the current source code and find out what to change and/or add to make it behave as expected. I studied how to monitor the evolution of the source code, how to prevent it’s decaying and how to remedy bad situations; People: One of the fundamental asset of people dealing with maintenance is the knowledge they have, of computer science (programming techniques), of the application domain, of the software itself. It is highly significant that from 40% to 60% of software maintenance time is spent reading the code to understand what it does, how it does it, how it can be changed; Organization: Organizations may have a strong impact on the way activities such as software maintenance are performed by their individual members. The support offered within the organization, the constraints they impose, the cultural environment, all affect how easy or difficult it can be to do the tasks and therefore how well or badly they can be done. I studied some software maintenance processes that organizations use.

What: Formalizing and Mining Knowledge from Uncontrolled Textual Assets: Two case studies
Who: Nicolas Sannier (Inria Rennes)
When: April 17th, 11h45 – 12h30
Where: Amphi Turing, Bat M3, Laboratoire d’Informatique Fondamentale de Lille , Université Lille 1

Abstract: Uncontrolled written natural language is by far the most widely used communication medium, providing very convenient, quick, simple ways for people to give information, disregarding their background, their concerns, their culture. In software development, in industry, in marketing, text is the very very first class input entity toward more complex artifacts and features. As is, it represents a huge body of valuable information. We present our recent research investigations into formalizing and analyzing large amounts of uncontrolled textual assets using a mix of modeling, natural language processing, information retrieval. Our work take place within two different case studies. The first case is related to the very complex nuclear energy industry and its regulatory requirements. The second case is about the everyday life and (not so) simple domain of product comparison matrices.

Further reading:
INCREMENT: A Mixed MDE-IR Approach for Regulatory Requirements Modeling and Analysis (REFSQ’2014 )
From Comparison Matrix to Variability Model The Wikipedia Case Study (ASE’2013)
Comparing or Configuring Products: Are We Getting the Right Ones (VAMOS’2014)

What: Building dynamic applications
Who: Walter Rudametkin (Inria Rennes)
When: April 17th, 11h – 11h45
Where: Amphi Turing, Bat M3, Laboratoire d’Informatique Fondamentale de Lille , Université Lille 1

Abstract: Robusta is an architectural approach to building component-based, multi-threaded, centralized (i.e. single memory space) dynamic applications. Our key insight are : a) handling dynamism is very invasive but it is not needed everywhere, b) dynamism should be managed early and at the architectural level, c) dynamism should never corrupt an application. We propose three different dynamic behaviors for specifying components (Stable, Detachable, Volatile), and an Extended Service Contract concept to better analyze and decouple components. We also look into programming restrictions, component decoupling, component packaging, and change impact analysis when building dynamic applications.

What: How to maximize the reuse of software systems
Who: Huaxi Yulin Zhang
When: April 17th, 10h15 – 11h
Where: Amphi Turing, Bat M3, Laboratoire d’Informatique Fondamentale de Lille , Université Lille 1

Abstract: To achieve better software, more quickly and at lower cost, the best solution is systematic software reuse from the development to evolution. In this presentation, we firstly illustrate a component-based development and evolution process based on Dedal – an ADL. However, in reality, there are too many problems to apply this process. We use robotics domain as an example to explain the practical reuse requirements and illustrate a new reuse framework.

What: Modélisation et test de mécanismes de sécurité
Who: Tejeddine MOUELHI (University of Luxembourg)
When: April 15th, 13h15
Where: B31

Abstract:Dans cet exposé, seront présentés des travaux autour de la modélisation et de la validation de la sécurité, plus précisément dans le domaine du contrôle d’accès et des applications webs. Dans le domaine de la modélisation, les travaux de recherche qui seront présentés sont autour de l’application de l’ingénierie dirigée par les modèles au domaine du contrôle d’accès pour automatiser à la fois la modélisation ainsi que le déploiement de politique de sécurité, mais aussi préparer la phase de test des mécanismes de contrôle d’accès. Concernant la partie validation, le test à partir de modèle ainsi que l’application de techniques de mutation seront également abordés. Enfin, dans cet exposé seront aussi présentés les travaux sur la sécurisation et le test d’application web. Pour finir, il y aura une discussion sur comment faire la jonction entre ces travaux et les thématiques abordées par Spirals, pour de futurs travaux.

What: Support For Implementation Regularities
Who: Angela Lozano
When: Friday, April 18th, 13h
Where: B31

Bio:

Angela Lozano is currently a Postdoc at the Software Languages Lab in Brussels, and uses Pharo for her research.

Abstract:

We have developed a set of tools to provide recommendations for developers and maintainers.
These tools are based on the assumption that source code is the most reliable and most up to date artifact in the software development process.
Their recommendations aim at increasing awareness and adherence to implementation regularities.
Implementation Regularities are manifestations of design knowledge in the form of recurrent implementation choices (e.g., coding idioms, naming conventions and design patterns).
Therefore, our tools aim at making design knowledge explicit without adding new artifacts.
This talk presents the aforementioned tools, their features and limitations, and the techniques they use for detecting relevant, intuitive, and concise recommendations.
Finally, it will also discuss early results on an analysis of code-critics’ results.

What: Touch first: Opportunities to reinvent computing
When: March 6th, 10h30
Where: B31
Who: Jochen Rick http://home.cc.gatech.edu/je77/research

ABSTRACT
Every fifteen years or so, new technology begets a computing revolution. We are in the early stages of the touch revolution. In 2013, there were more multi-touch tablets sold than laptops and desktops combined. Since 2007, I have been exploring the use of multi-touch technologies (interactive tabletops and tablets) to support co-located collaboration. In this talk, I reflect on what I’ve learned and propose an agenda for progress on touch interfaces. As an educational technologist, most of my applications have been aimed at children. Children are great users to explore the future of computing: They are not tied to existing conventions and will actively explore an interface to understand it. In addition, touch suits them. YouTube features many videos of young babies using their parents’ touch devices. These children will never switch to the mouse / keyboard interfaces of their parents. Let’s design computing interfaces appropriate to them. Let’s discard the conventions of the previous computing epoch and build native touch interfaces. To date, touch devices have been primarily used for consuming media (e.g., watching videos, surfing the Web, reading email). Gradually, their purview is expanding to creating media (e.g., editing video). How do we further these creative uses? Can we create a touch-based programming environment that is superior to today’s desktop IDEs? If so, then we have a real opportunity to reinvent computing for this “touch first” generation.

SPEAKER
Jochen “Jeff” Rick is on the faculty of the Department of Educational Technology, Saarland University, Germany. From 2007 to 2010, he worked as a postdoc on the ShareIT project, researching the value of interactive tabletops to support collaborative learning. In 2007, he received a PhD in Computer Science in the area of Learning Sciences and Technology from Georgia Tech. His research interests are in designing innovative applications for leading-edge technologies to support collaborative learning through active inquiry, exploration and construction. He has been programming in Smalltalk since 1999.

Email: j.rick@edutech.uni-saarland.de
Home page: http://je77.com/research