Program Comprehension

In order to make frameworks easier to use we need to better understand the difficulties that programmers have with them. The questions that programmers ask give clues to the quality of design, documentation, and programmer practice. We describe the method and results of a study on the Java Swing framework. We collected and analyzed a sample of 300 newsgroup questions asked about two Swing components (JButton and JTree), and classified the questions according to the design features of the components. This process revealed key insights that can improve a framework's design, its tutorials, and programmer practice.

In the context of program understanding, a challenge research topic 1 is to learn how techniques and tools for the comprehension of General-Purpose Languages (GPLs) can be used or adjusted to the understanding of Domain-Specific Languages (DSLs). Being DSLs tailored for the description of problems within a specific domain, it becomes easier to improve these tools with specific visualizations (at a higher abstraction level, closer to the problem level) in order to understand the DSLs programs. In this paper, comprehension techniques will be applied to Karel language. This will allow us to explore the creation of problem domain visualizations for this language and to combine both problem and program domains in order to reach a full understanding of Karel programs.

Program conditioning consists of identifying and removing a set of statements which cannot be executed when a condition of interest holds at some point in a program. It has been applied to problems in maintenance, testing, re-use and re-engineering. Program conditioning relies upon both symbolic execution and reasoning about symbolic predicates. Automation of the process therefore requires some form of automated theorem proving. However, the use of a full-power 'heavyweight' theorem prover would impose unrealistic performance constraints. This paper reports on a lightweight approach to theorem proving using the FermaT simplify decision procedure. This is used as a component to ConSUS, a program conditioning system for the Wide Spectrum Language WSL. The paper describes the symbolic execution algorithm used by ConSUS, which prunes as it conditions. The paper also provides empirical evidence that conditioning produces a significant reduction in program size and, although exponential in the worst case, the conditioning system has low degree polynomial behaviour in many cases, thereby making it scalable to unit level applications of program conditioning.

Program slicing has long been used to facilitate program understanding. Several approaches have been suggested for computing slices based on different perspectives, including forward slicing, backward slicing, static slicing, and dynamic slicing. The applications of slicing are numerous, including testing, effort estimation, and impact analysis. Surprisingly, given the maturity of slicing, few approaches exist for visualizing slices. In this paper, we present our tool for visualizing large systems based on program slicing and through two visualization idioms: treemaps and bipartite graphs. In particular, we use treemaps to facilitate slicing-based navigation, and we use bipartite graphs to facilitate visual impact analysis by displaying relationships among system decomposition slices showing the relevant computations involving a given slicing variable. We believe our tool will support various software maintenance tasks, including providing analysts an interactive visualization of the impact of potential changes, thus allowing them to plan maintenance accordingly. Finally, we show that, through the use of both existing scalable slicing and scalable visualization approaches, our tool can facilitate analysis of large software systems.

Program slicing has long been used to facilitate program understanding. Several approaches have been suggested for computing slices based on different perspectives, including forward slicing, backward slicing, static slicing, and dynamic slicing. The applications of slicing are numerous, including testing, effort estimation, and impact analysis. Surprisingly, given the maturity of slicing, few approaches exist for visualizing slices. In this paper, we present our tool for visualizing large systems based on program slicing and through two visualization idioms: treemaps and bipartite graphs. In particular, we use treemaps to facilitate slicing-based navigation, and we use bipartite graphs to facilitate visual impact analysis by displaying relationships among system decomposition slices showing the relevant computations involving a given slicing variable. We believe our tool will support various software maintenance tasks, including providing analysts an interactive visualization of th...

An efficient lightweight forward static slicing tool is presented. The tool is implemented on top of srcML, an XML representation of source code. The approach does not compute the full program dependence graph but instead dependency information is computed as needed while computing the slice on a variable. The result is a list of line numbers, dependent variables, aliases, and function calls that are part of the slice for a given variable. The tool produces the slice for all variables in a system. The approach is highly scalable and can generate the slices for all variables of the Linux kernel in less than 15 minutes. A demonstration video is at: • Software and its engineering Software creation and management Keywords

Comprehending programs is key to learning programming. Previous studies highlight novices' naive approaches to comprehending the structural, functional, and behavioral aspects of programs. And yet, with the majority of them examining on-screen programming environments, we barely know about program comprehension within physical computing-a common K-12 programming context. In this study, we qualitatively analyzed think-aloud interview videos of 22 high school students individually comprehending a given text-based Arduino program while interacting with its corresponding functional physical artifact to answer two questions: 1) How do novices comprehend the given text-based Arduino program? And, 2) What role does the physical artifact play in program comprehension? We found that novices mostly approached the program bottom-up, initially comprehending structural and later functional aspects, along different granularities. The artifact provided two distinct modes of engagement, active and interactive, that supported the program's structural and functional comprehension. However, behavioral comprehension i.e. understanding program execution leading to the observed outcome was inaccessible to many. Our findings extend program comprehension literature in two ways: (a) it provides one of the very few accounts of high school students' code comprehension in a physical computing context, and, (b) it highlights the mediating role of physical artifacts in program comprehension. Further, they point directions for future pedagogical and tool designs within physical computing to better support students' distributed program comprehension. • Applied computing → Interactive learning environments.

Graph visualisation is a well-known and researched field of graphical informatics. Several good algorithms were developed and reviewed by our days. However, most of the graph drawing tools mainly focus on static drawing generation. In this paper we present an approach that is efficient enough to visualise the user-requested parts (views) of a relatively large Semantic Program Graphs of Erlang projects in soft realtime. With the presented approach the visualised graphs can be traversed interactively, by changing between different levels of detailed information, which may support code comprehension in the RefactorErl framework.

Conditioned slicing can be applied to reverse engineering problems
which involve the extraction of executable fragments of code in the
context of some criteria of interest.  This paper introduces ConSUS,
a conditioner for the Wide Spectrum Language, WSL.  The symbolic
executor of ConSUS prunes the symbolic execution paths, and its
predicate reasoning system uses the FermaT "Simplify"
transformation in place of a more conventional theorem prover.
We show that this combination of pruning and simplification-as-reasoner
leads to a more scalable approach to conditioning.

A novel framework to evaluate computer programming labs is proposed. The primary focus is fair and effective evaluation of programming labs. The proposed framework includes a user friendly interface for instructor to detect cheating and evaluate submitted programs. Every submitted program is first checked against predefined test cases. If the program passes through test cases, then it is checked for plagiarism. Finally, the program is checked for performance.

Recent IDEs have become more extensible tool platforms but do not concern themselves with how other tools running on them collaborate with each other. They compel developers to use proprietary representations or the classical abstract syntax tree (AST) to build source code tools. Although these representations contain sufficient information, they are neither portable nor extensible. This paper proposes a tool platform that manages commonly used, fined-grained, information about Java source code by using an XML representation. Our representation is suitable for developing tools which browse and manipulate actual source code, since the original code is annotated with tags based on its structure and retained within the tags. Additionally, it exposes information resulting from global semantic analysis, which is never provided by the typical AST. Our proposed platform allows the developers to extend the representation for the purpose of sharing or exchanging various kinds of information about the source code, and also enables them to build new tools by using existing XML utilities.

Recent IDEs have become more extensible tool platforms but do not concern themselves with how other tools running on them collaborate with each other. They compel developers to use proprietary representations or the classical abstract syntax tree (AST) to build source code tools. Although these representations contain sufficient information, they are neither portable nor extensible. This paper proposes a tool platform that manages commonly used, fined-grained, information about Java source code by using an XML representation. Our representation is suitable for developing tools which browse and manipulate actual source code, since the original code is annotated with tags based on its structure and retained within the tags. Additionally, it exposes information resulting from global semantic analysis, which is never provided by the typical AST. Our proposed platform allows the developers to extend the representation for the purpose of sharing or exchanging various kinds of information about the source code, and also enables them to build new tools by using existing XML utilities.

Currently, research indicates that comprehending code takes up far more developer time than writing code. Given that most modern programming languages place little to no limitations on identifier names, and so developers are allowed to choose identifier names at their own discretion, one key aspect of code comprehension is the naming of identifiers. Research in naming identifiers shows that informative names are crucial to improving the readability and maintainability of programs: essentially, intention-revealing names make code easier to understand and act as a basic form of documentation. Poorly named identifiers tend to hurt the comprehensibility and maintainability of software systems. However, most computer science curricula emphasize programming concepts and language syntax over naming guidelines and conventions. Consequently, programmers lack knowledge about naming practices. This article is an extension of our previous study on naming practices. Previously, we set out to exp...

Translation between natural language and source code can help software development by enabling developers to comprehend, ideate, search, and write computer programs in natural language. Despite growing interest from the industry and the research community, this task is often difficult due to the lack of large standard datasets suitable for training deep neural models, standard noise removal methods, and evaluation benchmarks. This leaves researchers to collect new small-scale datasets, resulting in inconsistencies across published works. In this study, we present CoDesc -a large parallel dataset composed of 4.2 million Java methods and natural language descriptions. With extensive analysis, we identify and remove prevailing noise patterns from the dataset. We demonstrate the proficiency of CoDesc in two complementary tasks for code-description pairs: code summarization and code search. We show that the dataset helps improve code search by up to 22% and achieves the new state-of-the-art in code summarization. Furthermore, we show CoDesc's effectiveness in pre-training-finetuning setup, opening possibilities in building pretrained language models for Java. To facilitate future research, we release the dataset, a data processing tool, and a benchmark at .

Background Upazila Health Complexes (UHCs) and District Hospitals (DHs) play a crucial role in the healthcare delivery system of Bangladesh. But very few research has been conducted to find out the prevailing challenges of the medical officers working in these tiers. The objective of the study was to identify the challenges faced by medical officers in providing healthcare services at UHCs and DHs. Methods In-depth interviews of 51 medical officers from 17 UHCs and nine DHs were done between March and April 2021. All participants were purposively sampled. Data were transcribed verbatim and analysed using thematic analysis. Findings Inadequate service rooms, unavailability of proper medical equipment, poor housing conditions, lack of public amenities, shortage of health workforce, lack of laboratory services, and excessive workload were the common challenges mentioned by the medical officers in providing healthcare services in UHCs and DHs. Lack of workplace safety, security, and undue pressure from local political leaders and journalists made the work environment fearful. The absence of proper implementation of policy related to higher education, posting, transfer, and promotion was also stated as challenge for the medical officers. Interpretation Infrastructural improvements along with increased safety and security of the doctors at their workplace and transparent implementation of reformed policies are essential to reduce the workplace challenges of medical officers in UHCs and DHs of Bangladesh.

What kinds of feedback can we give to students as part of a computer-based system for supporting programming? One kind of feedback is whether the idioms that students use in their programs are typical of experienced programmers. In this paper we talk about how such idioms/patterns/roles/clich303251s are used in a tacit fashion by experienced programmers, and how natural language tags for such idioms (eg roles of variables) can be used to articulate this knowledge. Based on these ideas we suggest a strategy for giving ...

This paper discusses reverse engineering source code to produce UML sequence diagrams, with the aim to aid program comprehension and other software life cycle activities (e.g., verification). As a first step we produce scenario diagrams using the UML sequence diagram notation. We build on previous work, now combining static and dynamic analyses of a Java software, our objective being to obtain a lightweight instrumentation and therefore disturb the software behaviour as little as possible. We extract the control flow graph from the software source code and obtain an execution trace by instrumenting and running the software. Control flow and trace information is represented as models and UML scenario diagram generation becomes a model transformation problem. Our validation shows that we indeed reduce the execution overhead inherent to dynamic analysis, without losing in terms of the quality of the reverse-engineered information, and therefore in terms of the usefulness of the approach (e.g., for program comprehension).

This paper describes the use of search techniques to ease the burden of software maintenance for Services Oriented Architecture composite applications. Services Oriented Architecture is a paradigm that offers many potential business and social benefits, especially because it creates opportunities for composite software applications that share data and functionality across organizational boundaries. However, along with these benefits will come new challenges in the maintenance of these applications. The first necessity in any software maintenance task is to comprehend how the existing software functions. To gain this comprehension, maintainers will need to study a bewildering variety of artifacts, ranging from XML-based interface descriptions, through source code in a variety of languages, to traditional text documents in many different formats. For some years, we have been experimenting with the use of modern search techniques, enhanced where possible by rule-based reasoning, to aid...

In this paper we report partial progress of our research about system comprehension. We used levels of abstraction and decomposition strategy to reduce system complexity. Concept Relationship Oriented methodology is one of its result, the methodology can be used, to develop new artifact for reverse engineering. There are two significant reported activities: searching Concept Representation, and searching Structure of Concept. Searching Concept Representation was a process, to find a representation, proper or might exist less depend on artifact types (for example: unique concepts). In this stage dependency on level of abstraction still tight, but at the second stage we found the representation, Structure of Concept.

While code understanding is the primary program comprehension activity, it is quite challenging to recognize the application requirements from code, since they have usually been occluded by a set of layers of later implementation decisions. An alternative source of evidence, especially valuable for understanding the purposes for which the application was built, can be the dynamic behavior of the system, and more specifically the system-user interaction. We have developed a method for modeling the application behavior from the user's perspective in the form of use case models, using recorded traces of system-user interaction. We use data mining and pattern matching methods to mine these traces for frequently occurring user tasks. When interesting patterns are discovered, they are augmented with semantic information and they are used to build use case models. We demonstrate a successful application of this method to recover use case models from interaction traces with legacy 3270 systems to serve user interface reengineering activities.

We consider a while loop on some space S and we are interested in deriving the function that this loop defines between its initial states and its final states (when it terminates). Such a capability is useful in a wide range of applications, including reverse engineering, software maintenance, program comprehension, and program verification. In the absence of a general theoretical solution to the problem of deriving the function of a loop, we explore engineering solutions. In this paper we use a relational refinement calculus to approach this complex problem in a systematic manner. Our approach has many drawbacks, some surmountable and some not (being inherent to the approach); nevertheless, it offers a way to automatically derive the function of loops or an approximation thereof, under some conditions.

Improving youth science comprehension is critical to youth development, yet this intended outcome is often overlooked in terms of how Extension programs are delivered. The purpose of the study reported in this article was to determine through the assessment of potential student growth whether applying features of a youth science comprehension model to an Extension youth development program targeting underserved middle-school youths led to improved student academic achievement. Program delivery incorporating key features of the model resulted in improved scores for youths performing at or below grade level. These results suggest that the model offers a promising tool for improving youth science comprehension through Extension programming.

With the recent success of embeddings in natural language processing, research has been conducted into applying similar methods to code analysis. Most works attempt to process the code directly or use a syntactic tree representation, treating it like sentences written in a natural language. However, none of the existing methods are sufficient to comprehend program semantics robustly, due to structural features such as function calls, branching, and interchangeable order of statements. In this paper, we propose a novel processing technique to learn code semantics, and apply it to a variety of program analysis tasks. In particular, we stipulate that a robust distributional hypothesis of code applies to both human-and machine-generated programs. Following this hypothesis, we define an embedding space, inst2vec, based on an Intermediate Representation (IR) of the code that is independent of the source programming language. We provide a novel definition of contextual flow for this IR, leveraging both the underlying data-and control-flow of the program. We then analyze the embeddings qualitatively using analogies and clustering, and evaluate the learned representation on three different high-level tasks. We show that even without fine-tuning, a single RNN architecture and fixed inst2vec embeddings outperform specialized approaches for performance prediction (compute device mapping, optimal thread coarsening); and algorithm classification from raw code (104 classes), where we set a new state-of-the-art. 32nd Conference on Neural Information Processing Systems (NeurIPS 2018),

Despite general agreement among practitioners and educators alike that the application of solid uniform coding guidelines is beneficial, the application of coding standards in computer science education seem to be problematic. We applied interpretive research to arrive at an understanding of the attitude of leturers towards coding standards. We identified five aspects of coding guidelines through reasoning about proposed categorisation of coding guidelines found in the literature. We discuss the viewpoints of the interviewed lecturers in terms of these aspects. We conclude with our recommendations to promote the teaching of good programming practices in higher education.

Libraries are the most widespreaded form of software reuse. In order to properly use a library API, its clients should fulfill a series of (many times implicit) assumptions made by the API programmers. Failing to fulfill these assumptions leads to a misuse of the library and thereby to defects in the client's code. In this paper we present a method for checking a well-behaved usage of an API through a set of context-sensitive syntactic constraints over the API clients. These constraints restrict the set of programs that can be written with an API only to programs that fulfill the API assumptions and thereby represent a well-behaved and valid usage of the API. In this paper we present a set of typical assumption classes made by API providers about their clients. We define a framework for formalizing the contextsensitive constraints over the API client code and propose a typical constraint for each class of assumptions. Thereby we provide a mechanism that allows the provider of an API to describe the knowledge of how an API is intended to be used in an automatically checkable form. We present our experience with parts of the Java Standard APIs. public class Stack { //package java.util; /** ... @throws: EmptyStackException -if this stack is empty. */ public Object pop() { ... } ... } a) Pop-Only-Non-Empty-Stacks public class File { //package java.io; /** [...] The return value should always be checked to make sure that the rename * operation was successful. */ public boolean renameTo(File dest) { ... } ... } b) Check-The-Return-Of-RenameTo public class Component { //package java.awt; /** ... This method is called internally by the toolkit and should not be called * directly by programs. */ public void addNotify() { ... } ... } d) Do-Not-Call-AddNotify public class Component { //package java.awt; /** [...] Subclasses [...] that override this method should either call super.update(g), * or call paint(g) directly from their update method */ public void update(Graphics g) { ... } ... }

While programming is modeling the reality, reverse engineering is concerned with recovering it from the code. Parts of this reality can be formalized as concepts and relations among them. As previous research suggests, the identification of these concepts is a key issue in automating program analysis. Their central role requires advance reverse engineering tasks to consider them first-class citizens. In this paper we unify the classical, structure-based reverse engineering meta-models with a meta-model describing concepts and their relations. Our unified meta-model establishes an explicit mapping between concepts and their implementations in a program. Instances of the meta-model are built in a semi-automatic manner by analyzing the program's identifiers. Using this model allows us to raise the abstraction level by viewing the program from the perspective of concepts it implements. This enables a higher degree of automation in the reverse engineering endeavor.

Learning to read source code is an important part of developing programming skills. Using pseudo-code and program traces for this allows creating exercises developing comprehension of basic algorithmic concepts like control structures, expressions, functions calls. However, such assignments require reading long traces and comparing them with the algorithm, identifying the control structures involved. Automatic generation of algorithms for assessments poses a particular problem because such algorithms lack an identified goal. While this is useful for learning to predict program traces without relying on the intuitive understanding of the algorithm, it doesn't allow using meaningful labels for the control structures comprising the algorithm's tree. This paper presents a study of students' preferences between different ways of writing algorithms and program traces. Eighty-one first-year computer science students completed a survey comparing eight ways of writing algorithms and four ways of writing program traces. The students preferred using expressions to identify control structures over short phrases or numbers. They had no clear preferences for the way the program traces were formulated. So a system, generating algorithms for assessments should also have a module generating expressions. These results are limited to university students; the preferences of other groups of learners should be studied separately.

Artificial intelligence (AI) has become increasingly influential in computer science (CS) education, where it holds potential for automating feedback and personalized learning. AI tools have been shown to increase equitability within CS, a notoriously male-dominated field, as well as increase the programming self-efficacy of female students-which is tied to programming success. This chapter will present a summary of how students learn to code, studies explaining how AI can be used to help students understand code, as well as provide prompt feedback for students coding in real-time. A history of the development of AI and its increasing accuracy is provided. To assess the impact of generative AI for assisting students in explaining code, the authors present data from a recent study examining the effectiveness of using AI to provide code explanations for novice programmers. The authors also provide some prompt engineering suggestions for educators to help their students increase the accuracy of the results from AI queries.

Despite existing methodologies in the field, most requirements engineers are poorly trained to define security requirements. This is due to a considerable lack of security knowledge. Some security ontologies have been proposed, but a gap still exists between the two fields of security requirement engineering and ontologies. This paper is a survey, it proposes an analysis and a typology of existing security ontologies and their use for requirements definition.

Recent popularity of mobile devices increased the demand for mobile network services and applications that require minimal delay. 5G mobile networks are expected to provide much lesser delay than the present mobile networks. One of the conventional ways for decreasing latency is caching content closer to end users. However, currently deployed methods are not effective enough. In this paper, we propose a new astute in-network caching framework that is able to smartly predict subsequent user requests and prefetch necessary contents to remarkably decrease the end-to-end latency in 5G mobile networks. We employ semantic inference by edge computing, deduce what the end-user may request in the sequel and prefetch the content. We validate the proposed technique by emulations, compare it with the state of the art and present impressive gains.

Test smells can reduce the developers' ability to interact with the test code. Refactoring test code offers a safe strategy to handle test smells. However, the manual refactoring activity is not a trivial process, and it is often tedious and error-prone. This study aims to evaluate RAIDE, a tool for automatic identification and refactoring of test smells. We present an empirical assessment of RAIDE, in which we analyzed its capability at refactoring Assertion Roulette and Duplicate Assert test smells and compared the results against both manual refactoring and a state-of-the-art approach. The results show that RAIDE provides a faster and more intuitive approach for handling test smells than using an automated tool for smells detection combined with manual refactoring.

The current article is an interdisciplinary attempt to decipher automatic program repair processes. The review is done by the manner typical to human science known as diffraction. We attempt to spot a gap in the literature of self-healing and self-repair operations and further investigate the approaches that would enable us to tackle the problems we face. As a conclusion, we suggest a shift in the current approach to automatic program repair operations in order to attain our goals. The emphasis of this review is to achieve full automation. Several obstacles are shortly mentioned in the current essay but the main shortage that is covered is the overfitting obstacle, and this particular problem is investigated in the stream that is related to full automation of the repair process.

Modern software development methodologies include reuse of open source code. Reuse can be facilitated by architectural knowledge of the software, not necessarily provided in the documentation of open source software. The effort required to comprehend the system's source code and discover its architecture can be considered a major drawback in reuse. In a recent study we examined the correlations between design metrics and classes' architecture layer. In this paper, we apply our methodology in more open source projects to verify the applicability of our method.

Due to continuous change in business requirements and to implement proactive, adaptive maintenance procedures in application program; it is required to evolve application program time to time. Program comprehension is a process of program understanding and reverse engineering, which supports the analyst to easily undertake the program for further reengineering. This paper highlights the program elements, components, its analytical solutions for understanding, comprehensions and extension.

In this paper, we propose a framework for reconstructing software architecture from a software system. The framework consists of the steps to reconstruct software architecture for modifying source code. The framework can be used for developers to analyze source code and reconstruct software architecture for modifying the code. In addition, we perform a case study by analyzing Reflexion Model, an open source code, to verify that the framework can be effectively applied to software architecture reconstruction. For that, we evaluate several tools in order to select those that support our reconstruction. Then we verify the framework and report several issues discovered with the case study. By applying the issues encountered in the case study to the framework, we have made our framework a more practical one that developers can easily understand and adopt.

Curriculum Vitae ix It does not happen often that you get the chance to acknowledge the people that make a difference for you, and, as I am getting to learn, people deserve to know that you appreciate them. I would start by saying that these 4 years I spent in Delft working on my PhD research have been particularly special for me, and not only because I got paid for doing what I like, but also because the people I met. It was an honour and a privilege to meet and work with Arie (prof. van Deursen), and just as much of a pleasure. If it is true that meeting a great mentor is (mainly) a matter of chance, then I can surely call myself lucky. During these years I collaborated, in various degrees, with a number of fellow researchers, and I had the opportunity to co-author papers with some of them: first of all Leon Moonen, then Paolo Tonella, Tom Tourwé, Kim Mens and Mariano Ceccato. I would like to thank them as well as the members of the committee for their valuable comments on this thesis: prof. dr. P. Tonella, prof. dr. S. Demeyer, prof. dr. P. Klint, prof. dr. C. M. Jonker, prof. dr. ir. H.J. Sips. A number of people who experimented with the tools I developed, FINT and SO-QUET, kindly provided me with their feedback, which I very much appreciate. I would also like to thank dr. Carlos Infante Ferreira, who supervised my Master's thesis in Delft, and who encouraged me to take on a PhD challenge. From the same group, I need to mention Dong-Seon Kim who was always available with a friendly advice. Eamonn McDonagh willingly went over some of my first paper drafts, and it was always fun and good lessons to have his comments. Coming back to SWERL, thanks to my "warriors", football and "borrel" teams (i.e., {{{Bas Cornelissen, Cathal Boogerd, Rui (...) Abreu}, Bas Graaf, Marco Lormans (also a very enjoyable tennis partner)}, Ali Mesbah (yes, we still need to write "that" paper together), Leon Moonen (WCRE in Delft was the most pleasant conference to me!), Gerd Gross, Peter Zoeteweij}), all of which I so gladly joined. You guys keep up the good work! Special thanks go to my room mates, Bas (alias sebas) and Andy Zaidman, who, xi besides accepting the shades to be raised, helped me so kindly with the Dutch summary. All the other colleagues in the group, particularly Frans Ververs, contributed to a special atmosphere. I shall conclude this part with two friends from completely different parts of the world: Giorgio Alfarano and Ulysses Locadia. It is always great, and so comforting, spending time with you. Last word is for my wife, Ioana: you know, all the good things are so because of you.