The teaching-learning process is complex in nature, requiring many tasks and skills to achieve success in the construction of knowledge.As per any particular kind of cognitive development, teaching and learning Computer Programming is no different in this regard: tasks must be executed, sometimes repeatedly, and skills must be developed.Despite different approaches and methodologies, exercising what has been studied is proven to be effective in pretty much any teaching-learning process.Many tools have been developed throughout time to aid in the execution of this important task, sometimes approaching the problem from the students' perspective, sometimes from the teachers'.This paper presents Goliath, a semi-automatic generator of Computer Programming exercises, whose functionality is based on Artificial Intelligence (AI) models, a Domain-Specific Language (DSL), and an online application that binds them together.Goliath's goals are directed towards teachers (and indirectly, students) by aiming to lower the burden of repeatedly constructing exercises.This is achieved through the use of templates that allow for automatic variations of an exercise to be created instantly, while relying on a common foundation.Goliath is meant to be a facilitator, raising availability of exercise lists, while avoiding repetition and the common mistakes that accompany their construction.

An ever-growing landscape of programming technologies (tools, languages, libraries and frameworks) has rapidly become the norm in many domains of computer programming-Web Development being the most noticeable example.The concurrent use of many compartmentalised technologies has advantages: it allows for flexibility in implementation, while also improving reusability.On the other hand, this proliferation tends to create convoluted development workflows that must be (painstakingly) planned, managed and maintained.The combination of multiple languages, libraries, frameworks and tools (Ingredients) in a single project effectively forms a Programming Cocktail, that can rapidly become cognitive and financially onerous.Aiming at understanding these complex situations, an ontology was created to provide a formal and structured analysis of these cocktails.It emerged from a survey of technologies that several companies are currently using to develop their systems, and aims to provide support for better understanding, classifying and characterising Programming Cocktails.This paper presents not only the ontology itself, but also the consequent knowledge that was constructed and structured through its development.

Abstract Business process model and notation (BPMN) is a popular notation used for process modelling mainly due to its high expressiveness. However, BPMN has shortcomings when dealing with specific domains (namely Hazard Analysis and Critical Control Points systems), struggling to model activity duration, quality control points, activity effects and monitoring nature. To tackle these limitations, the business process model and notation extended expressiveness (BPMN-E2) was proposed. In this paper, a multiperspective conformance checking algorithm is developed focusing on detecting non-conformity between an event log and a process model, regarding the information provided by the new elements within BPMN-E2. The proposed algorithm follows a two-step approach that starts by converting the model into a directly follows model (annotated with conformance rules), which is then used in a second phase to perform conformance checking effectively. This modular approach allows to apply the proposed algorithm to other process model notations than BPMN-E2. An event log clustering technique was also developed to downsize large-event logs without compromising data relevance. In this way, both the multiperspective algorithm and the log-downsize clustering technique here proposed are a key contribution to improve conformance checking in process modelling, as evinced in the proof-of-concept provided.

According to the World Health Organization (WHO), close to 300 million people of all ages suffer from depression. Also, for WHO, depression is the leading reason for disability worldwide and is a major contributor to the global burden of disease. Different than the mood fluctuation raised by the common life's activities, depression can be a serious health problem, particularly when it is a long-term and mid/high intensity. Luckily, despite depression is a silent disease, people when suffering leaves some clues. Due to the massive use of social media, these clues can be collected through the texts posted on social media, such as Twitter, Facebook, Instagram, and later, analysed to identify if the writing style matches with a depressive pattern. This paper presents an approach that can be applied by Machine Learning models to help psychologists to identify depressive clues in texts. The model examines profiles on Twitter based on clues provided by users in their posts. Combining Sentiment Analysis, Machine Learning and Natural Language Processing techniques, we achieved a precision of 98% by Machine Learning models when identifying Twitter profiles that post potential depressive texts.

Abstract Writing style is considered the manner in which an author expresses his thoughts, influenced by language characteristics, period, school, or nation. Often, this writing style can identify the author. One of the most famous examples comes from 1914 in Portuguese literature. With Fernando Pessoa and his heteronyms Alberto Caeiro, Álvaro de Campos, and Ricardo Reis, who had completely different writing styles, led people to believe that they were different individuals. Currently, the discussion of authorship identification is more relevant because of the considerable amount of widespread fake news in social media, in which it is hard to identify who authored a text and even a simple quote can impact the public image of an author, especially if these texts or quotes are from politicians. This paper presents a process to analyse the emotion contained in social media messages such as Facebook to identify the author's emotional profile and use it to improve the ability to predict the author of the message. Using preprocessing techniques, lexicon‐based approaches, and machine learning, we achieved an authorship identification improvement of approximately 5% in the whole dataset and more than 50% in specific authors when considering the emotional profile on the writing style, thus increasing the ability to identify the author of a text by considering only the author's emotional profile, previously detected from prior texts.

Each programmer has his own way of programming but some criteria can be applied when analysing code: there are a set of best practices that can be checked, or "not so common" instructions that are mainly used by experts that can be found.Considering that all programs that are going to be compared are correct, it's possible to infer the experience level of the programmer or the proficiency level of the solution.The approach presented in this paper has as main goal to compare sets of solutions to the same problem and infer the programmers profile.This can be used to evaluate the programmer skills, the proficiency on a given language or evaluate programming students.A tool to automatically profiling Java programmers called PP (Programmer Profiler) is presented in this paper as a proof of concept.

Several applications are based on Domain-Specific Languages (DSL). They provide the right terminology to a peculiar problem/subject, because they use a particular domain vocabulary that defines abstract concepts, different from general-purpose languages. Aiming an easy generation of virtual Learning Spaces (LS) for the use of the responsible of institutional archives or museums, we have idealized and developed an external domain-specific language, called CaVa DSL, to describe, in an abstract level, virtual exhibition rooms in the museum curator's viewpoint, giving the curator the possibility to specify the virtual LS upon a domain ontology vocabulary. We also contribute with a set of processors that deal with CaVa DSL and generates virtual Learning Spaces, turning available the navigation over important and real information contained in archival documents to the public through virtual museums. To demonstrate the obtained results, we present a running example along the paper showing the virtual LS generation process.

One of the main reasons that justify the student’s failure in (introductory) programming courses is the lack of motivation that impacts on the knowledge acquisition process, affecting learning results. As soon as students face the difficulties concerning the development of algorithms or the coding in a programming language, they give up and do not try harder to solve other problems; they think it is a demanding activity and feel frustrated. In this paper we describe in detail an experiment conducted to verify the effectiveness, in terms of the increase in motivation and in knowledge acquisition, of combining program Animation tools with the immediate feedback provided by Automatic Evaluations Systems.

A good virtual Learning Space (LS) should convey pertinent learning information to the visitors at the most adequate time and locations to favor their knowledge acquisition. Considering the consolidation of the internet and the improvement of the interaction, searching, and learning mechanisms, we propose a generic architecture, called CaVa, to create virtual Learning Spaces building up on cultural institution documents. More precisely, our proposal is to automatically create ontology-based virtual learning environments. Thus, to impart relevant learning materials to the virtual LS, we propose the use of ontologies to represent the key concepts and semantic relations in an user- and machine-understandable format. These concepts together with the data (extracted from the real documents) stored in a digital storage format (XML datasets, relational databases, etc.) are displayed in an ontology-based learning space that enables the visitors to use the available features and tools to learn about a specific domain. According to the approach here discussed, each desired virtual LS must be specified rigorously through a domain specific language (DSL) that was designed and implemented. To validate the proposed architecture, three case studies will be used as instances of CaVa architecture.

The Semantic Web aims at building a Web where data is enriched with meaningful annotations. In other words, data is semantically organized in such a way that both human and machine can understand and query it, aiming at the creation of dynamic Web pages. Ontologies, as a keystone of the Semantic Web, have gained an ample acceptance as an information model, which can be used for several purposes, such as information retrieval in the Web. However, data is normally stored in databases, which present various problems in the Semantic Web context, because data is not semantically annotated. Aiming at retrieving rich results in the sense of meaning, several ways of relating databases with ontologies have emerged. This paper presents a mapping - with the aid of a framework called Ontop - as a solution for the communication problem between the relational database of the Emigration Museum of Fafe (EMF) and the ontology of the Emigration Museum (OntoME), which describes the Cultural Heritage domain. This mapping will be used to realize the CaVa architecture, aiming at the creation of dynamic Web pages as virtual Learning Spaces. Real examples of the mapping process are presented.

In this paper we support the idea that students and teachers will benefit from a computer-based system that assesses programming exercises and provide immediate and detailed feedback: students would be able to evolve in the right direction and teachers would follow and assess more fairly their students. This assessment should outperform the typical right/wrong evaluation returned by existing tools, allowing for a flexible partial evaluation. Moreover, we adopt a concept from Agile Development, the Continuous Integration (CI), to improve students’ effectiveness. The applicability of CI reflects a better monitoring by the teams and their individual members, also providing the ability to improve the speed of the development. Besides the description of the capabilities that we require from an Automatic Grading System (AGS), we discuss iQuimera, an improved AGS that we are working on, that implements our teaching/learning principles.

A central issue in program verification is the generation of verification conditions (VCs): proof obligations which, if successfully discharged, guarantee the correctness of a program vis-à-vis a given specification. While the basic theory of program verification has been around since the 1960s, the late 1990s saw the advent of practical tools for the verification of realistic programs, and research in this area has been very active since then. Automated theorem provers have contributed decisively to these developments. This paper establishes a basis for the generation of verification conditions combining forward and backward reasoning, for programs consisting of mutually-recursive procedures annotated with contracts and loop invariants. We introduce also a visual technique to verify a program, in an interactive way, using Verification Graphs (VG), where a VG is a Control Flow Graph (CFG) whose edges are labeled with contracts (pre- and postconditions). This technique intends to help a software engineer to find statements that are not valid with respect to the program's specification.

The RAISE'13 workshop brought together researchers from the AI and software engineering disciplines to build on the interdisciplinary synergies which exist and to stimulate research across these disciplines. The first part of the workshop was devoted to current results and consisted of presentations and discussion of the state of the art. This was followed by a second part which looked over the horizon to seek future directions, inspired by a number of selected vision statements concerning the AI-and-SE crossover. The goal of the RAISE workshop was to strengthen the AI-and-SE community and also develop a roadmap of strategic research directions for AI and software engineering.

Comments are interspersed by the Programmer among code lines, at software development phase, with two main purposes: to help himself during the development phase, to help other programmers later on, during the maintenance phase. The former are memos to help him remembering to do something, they are not useful for those willing to understand code. The latter are explanations about the ideas he has in mind when he wrote the code, they can be a relevant aid for others and should be taken into consideration as a first step in program comprehension. Comments are scattered all over the source code, sometimes wrapping a block of code (placed at the beginning or at its end), other times complementing a single statement. If comments are inserted to help in understanding the programmer ideas, they will contain for sure concepts associated with problem domain In this paper we discuss an approach to locate a relevant code chunk (one where the programmer should focus the attention for software maintenance), using information retrieval techniques to locate problem domain concepts within comments. In our approach, comments are isolated marking their type (inline, block or javadoc comment) and keeping their context (code lines to which they are associated). Picking up concepts from the ontology that describes the problem, it is possible to find all the comments that contain that concept (similar words) and rate them. Reading comments from the retrieved list, the programmer can select those that seem to him meaningful and dive directly into the associated chunk. In the paper, we also survey Comment Analysis techniques and describe an environment, Darius, that aims at automatizing the approach proposed. Moreover, Dariusprovides functionality to study comments frequency in the source files of a given project, to support the discussion weather it is worthwhile or not to apply this program comprehension step.

Abstract This paper revisits the idea of slicing programs based on their axiomatic semantics, rather than using criteria based on control/data dependencies. We show how the forward propagation of preconditions and the backward propagation of postconditions can be combined in a new slicing algorithm that is more precise than the existing specification-based algorithms. The algorithm is based on (a) a precise test for removable statements, and (b) the construction of aslice graph, a program control flow graph extended with semantic labels and additional edges that “short-circuit” removable commands. It improves on previous approaches in two aspects: it does not fail to identify removable commands; and it produces the smallest possible slice that can be obtained (in a sense that will be made precise). Iteration is handled through the use of loop invariants and variants to ensure termination. The paper also discusses in detail applications of these forms of slicing, including the elimination of (conditionally) unreachable and dead code, and compares them to other related notions.

This paper revisits the idea of slicing programs based on their axiomatic semantics, rather than using criteria based on control/data dependencies. We show how the forward propagation of preconditions and the backward propagation of post conditions can be combined in a new slicing algorithm that is more precise than the existing specification-based algorithms. The algorithm is based on (i) a precise test for removable statements, and (ii) the construction of a slice graph, a program control flow graph extended with semantic labels. It improves on previous approaches in two aspects: it does not fail to identify removable commands; and it produces the smallest possible slice that can be obtained (in a sense that will be made precise). The paper also reviews in detail, through examples, the ideas behind the use of preconditions and post conditions for slicing programs.

In the context of our research project, we are looking for program comprehension tools that are able to interconnect operational and behavioral views, aiming at aiding the programmer to relate problem and program domains to reach a full understanding of software systems. In particular we have been studying the adaptation of that principle to Web applications. In this context, we had designed and implemented a tool called WebAppViewer. In this paper, we emphasize the development of the module (BORS) that is responsible for providing interconnection functionalities and we propose a tool demonstration. A dedicated Web server is included in the system to allow the execution of the piece of code selected by the user. This feature is used to relate the source text (html, php, etc) executed by the server, with the web page received by the client. Code instrumentation is used to collect dynamic information.

In this paper, we discuss how to present the result of searching elements of any type from XML documents relevant to some information need (relevance-oriented search). As the resulting elements can contain each other, we show an intuitive way of organizing the resulting list of elements in several ranked lists at different levels, such that each element is presented only one time. Depending on the size of such ranked lists, its presentation is given by a structure tree, for small lists, or by a sequence of pointers, for large lists. In both cases, the textual content of the implied elements is given. We also analyse the size of ranked lists in a real collection of XML documents. Categories and Subject Descriptors

In this paper, we describe a system to interactively accede to XML documents represented by attribute grammars. The system has two main components: (1) the query editor/processor, where the user interactively specifies his needs; (2) the document analyzer, which performs operations for query evaluation that accede directly to the documents. The interactive construction of queries is based on the manipulation of intermediate results during query construction and evaluation. We believe this helps the user to achieve the desired result.

Relational databases have been used to support information storage for a long time. Maintenance and the natural growth of information systems imply the reuse of existing databases, but information is often not stored on the most convenient structure or on the desired platform; it then becomes necessary to export it into another system or to transform its structure. These tasks should be executed in a fast and safe way, with as much automation as possible. XML has been accepted as the neutral format for information representation. This is mainly due to two factors. On one hand, XML documents are purely textual files, structured and independent of any hardware or software platforms. On the other hand, more and more public domain tools are becoming available to help users transform XML documents. The paper focuses on the use XML as an interchange format between database management systems and presents an XML language, DBML, that allows the definition of the structure and content of a relational database. It also introduces a methodology to convert a database into a DBML document and two tools that allow transforming DBML documents into SQL and back. DBML and the two conversion functions (dbsql2dbml and dbml2dbsql) provided the basis to support the idea of designing a language to specify database transformations and developing a generator to automatically produce the transference processors; we finish the paper with the proposal of such a system.