dataesr/scientific-paragraphs-categorization huggingface dataset:
Agent-Oriented Software Engineering In their paper "Improving the Usability of a MAS DSML", which received the best paper award, Tomás Miranda, Moharram Challenger, Baris Tezel, Omer Faruk Alaca, Vasco Amaral, Miguel Goulão and Geylani Kardas point out the need for evaluating the usability of domain-specific modeling languages (DSMLs) for MASs especially to leverage the adoption of such languages by the agent developers during MAS design and implementation. Many MAS DSMLs are proposed by the AOSE researchers along with appropriate IDEs in which both modeling and code generation can be performed  [21]. However, the evaluation of these DSMLs is completely missing or has been carried out with an idiosyncratic approach  [9]. Miranda et al. focus on the usability of DSMLs for MAS and introduce an approach for promoting the usability of such languages by applying the principles of the "Physics" of Notations (PoN)  [27].
For this purpose, the visual notation of a MAS DSML, called SEA_ML  [8] , was evaluated and modified according to PoN principles which led to the development of the new version of the language, called SEA ML++. SEA ML++ was perceived as significantly improved in terms of the concrete syntax's comprehensibility, adequacy and usability, as a direct result of employing the PoN principles. Artur Freitas, Rafael H. Bordini and Renata Vieira present their proposal for the "Automatic Generation of Multi-Agent Programs from Ontology Models". The foundation of such work, aimed at facilitating the development of MASs designed as ontology models supporting code generation, takes into consideration ontologies for agent-oriented software engineering aligned with the JaCaMo framework  [5]. These techniques are implemented in a tool that supports multi-agent systems core code generation for JaCaMo, and the underlying ontology also allows for reasoning about the MAS models under development.
In a hypermedia MAS, inline with the notion of agent environments  [48] , agents are situated in a distributed hypermedia environment that they can navigate and use in pursuit of their goals. Agents use the hypermedia to discover: (i) other entities in the MAS (e. g. , other agents, tools, knowledge repositories, organizations, datasets etc. ), and (ii) means to interact with those entities. This allows the MAS to evolve at runtime and to be seamlessly distributed across the Web. The authors report on a demonstrator in which BDI agents are able to use hypermedia to discover and interact with artifacts that are deployed at runtime and can evolve independently from the rest of the system.
Maira Gatti de Bayser, Claudio Pinhanez, Heloisa Candello, Marisa Affonso Vasconcelos, Mauro Pichiliani, Melina Alberio Guerra, Paulo Cavalin and Renan Souza present "Ravel: A MAS Orchestration platform for Human-Chatbots Conversations". Ravel is a MAS aimed to integrate natural language understanding components with orchestration components of dialogues between human beings and agents. Ravel enables the specification of (social) conversations norms, using deontic logic, for use in contexts where multiple agents and human users are conversing in natural language. The usefulness of Ravel has been demonstrated in a chat-based finance adviser system designed as a chat group of five participants: four collaborative chatbots with two different roles (mediator and expert) and a human or chatbot user.
While exposing agents as web services is not a novel approach, the objective of this work is to understand (i) what is the current state of production-ready MAS, and (ii) how hard it is for a software developer to understand and implement an agents-based solution. For this reason, the Smart Agenda MAS was implemented by first-year graduate students (masters), which allowed the authors to observe how a MAS using very well-known Internet-related paradigms can be modeled and implemented by developers that never had any contact with agent technologies. It was also possible to critically evaluate the learning curve involving the technologies used in the implementation (JADE  [4]  and BDI4JADE  [29] ).
Although both goals and beliefs may be modeled as facts in a Prolog-like setting, adding a new goal is more expensive than inserting a new belief, as in the second case there is no need for consistency checking (at least in such a database which only consists of positive literals), but some basic rationality constraints such as that the goal is not believed to be the case must be ensured in the first case. Also, goal management usually takes temporal aspects into account: as an example, "Alice may want to go to the library and to the movies", but this is typically meant in a temporal sense as she cannot be in two places at the same time.
Given this observation it is important to investigate the integration between cognitive agent frameworks and other decisionmaking/reasoning models which is far from trivial. Hence, there is a need to investigate "dynamic" cognitive agent architectures that allow an agent to have multi-modal reasoning methods. An important additional motivation here (not highlighted above) is the huge variety of data that a real agent/MAS has to handle. The group was keen to highlight that such integrative work should be undertaken with a view to creating a coherent architecture and not on developing ad hoc solutions to specific problems. There is also scope for work on mapping the space of agent programming languages, specifically in understanding what they are and what they are not, since these languages are notable for an assumption that they are embedded in larger software systems with some aspects of computation delegated outside the agent.
Why is the topic important? Programming languages are crucial tools for expressing and realizing software systems. The right programming language can make a huge difference to the ease of writing (and modifying) software. Accordingly, it is hardly surprising that there has been substantial work on specialist programming languages for developing multi-agent systems. However, agent-oriented programming has not caught on, and one argument for why this is the case  [23]  is that Agent-Oriented Programming Languages (AOPLs) fail to provide the right balance of features: they leave too much to the programmer to specify, so that the overall benefit does not, in many cases, outweigh the learning cost. The diffusion of MAS applications in the real world has not reached its full potential yet. Reasons for this can be found for example in  [47, 30].
MAS and ML use different technological ecosystems. Many frameworks that are frequently used by the MAS community -for example Jason and JaCaMo -have not widely been adopted in practice and are dependent on technologies that are losing traction in the industry. In contrast, technologies that are popular among members of the ML community, like TensorFlow  [1] , Keras 4 , and OpenAI Gym 5 are increasingly popular among software engineering practitioners. It is up to the MAS community to bridge this gap to have an impact outside of academia.
Why is the topic important? Finding boundaries between AOSE approaches and other SE methods: AOSE is a very powerful approach to understand, describe and design complex systems, although agents are not necessarily implemented into the final systems in their pure theoretical form, and using purely agent-oriented languages like Jason, 3APL, etc. Rather, 4 Keras: The Python Deep Learning library, https://keras. io/ 5 A toolkit for developing and comparing reinforcement learning algorithms, https://gym. openai. com/ agents may be built into applications by exploiting tools and languages which are specific to the given application domain, and which prove more suitable than standard agent programming languages in that specific context. A better understanding of the relationships between AOSE stages and more widespread and consolidated SE approaches/tools/languages would allow AOSE and agent technology to be more easily accepted for the engineering stages where they give concrete advantages, and complemented with other domain-specific solutions when they better fit the developers' needs.
Finding boundaries between applications that do need agents, and applications that do not need them: Also, not all the applications require to be engineered following an AOSE approach: think for example of monolithic and centralized applications, that do not need to be aware of the surrounding environment. Despite their relevance, flexibility and capabilities, agents are not necessarily meant to be used everywhere. Although dating back to almost twenty years ago, the survey by Stone and Veloso  [35]   The features mentioned by Stone and Veloso make agents and MAS programming appealing for facing the engineering challenges raised by nowadays complex applications, including the "Internet of Smart Things": IoT systems which must be resilient, efficient, and "smart"  [26, 31]. When agents are cognitive ones, the ability to explicitly model themselves, other agents, and the surrounding environment, and to reason about these models, can be exploited to pursue machine ethics 6  also following some ethics-aware software engineering approach  [3].
CONCLUSIONS The goal of engineering processes is to design and implement systems that meet the design criteria, and to show that the final product actually satisfies the specifications. Current software engineering practices focus mainly on the creation process (technical-engineering aspect) in the hope that good practices and tools lead to good products, because the theoretical approach is considered too complex. However, a good design needs strong theoretical background to select the best architectural and algorithmic design options. This is even more important for engineering MAS, because ensuring the global behavior of large-scale MAS includes not only implementing agents that reach their goals, but also designing how the environment, the agents, the organization of the agents can interact with each other (theoretical-MAS aspect) in order to optimize their global behavior.
ACKNOWLEDGMENTS  Arthur Casals  is supported by  CNPq , grant no. 142126/2017-9. Eleonora Giunchiglia  is supported by the  EPSRC , under grant  EP/M508111/1 , and the  Oxford-DeepMind Graduate Scholarship. Timotheus Kampik  is supported by the  Wallenberg AI, Autonomous Systems and Software Program (WASP)  funded by the  Knut and Alice Wallenberg Foundation. Geylani Kardas ,  Moharram Challenger  and  Baris Tekin Tezel  are supported by the  Scientific and Technological Research Council of Turkey (TUBITAK)  under grant  115E591. Simon Mayer  is supported by the  Austrian FFG  under grant # 854184  (COMET). The work of  László Z. Varga  was carried out in the project  EFOP-3. 6. 3-VEKOP-16-2017-00001 :Talent Management in Autonomous Vehicle Control Technologies -The Project is supported by the  Hungarian Government  and co-financed by the  European Social Fund.
69, p >. 20). The speech rate model revealed a significant main effect of type of knowledge (X 2 = 37. 37, p <. 0001) due to faster speech rate in the shared knowledge condition compared to the not- shared knowledge condition. The effect of informational status was not significant (X 2 = 4. 25, p =. 12). The informational status x type of knowledge interaction was also significant (X 2 = 7. 60, p <. 05). Multiple comparisons (Tukey test, p <. 05) obtained with the glht function from the multcomp package (  [37] ) with p-values adjusted by the single step method revealed that this significant interaction was due to faster speech rate in the contrastive noun condition compared to the contrastive fragment condition (z = 3. 00, p <. 05) and a tendency for faster speech rate in the contrastive noun condition compared to the contrastive adjective condition (z = 2.
Prosodic encoding of informational status Proportion of items in the coded sample that included 2 APs depending on the type knowledge shared by participants and the informational status of target fragments shared is shown in Table  2. As shown in Table  2 , there was a large bias in favor of the 1 AP phrasing compared to the 2 AP phrasing regardless of the type of knowledge and of the informational status of target fragments. We used a mixed-effects regression model (lme4 package in R-studio statistics Version 0. 99. 903) with a logistic linking function to confirm the statistical relevance of this bias. The model included the AP phrasing as dependent variable (1 = 2 APs, 0 = 1AP), the informational status (contrastive adjective, contrastive noun, contrastive fragment), the type of knowledge (shared-knowledge, not-shared knowledge) and the interaction between the two factors as fixed effects.
Experiments In this experimental section we present some results obtained using the described algorithms (and the corresponding proposed implementations). The input image of size 584 × 388 that we use is shown in Figure  2. This is the grayscale version of the RubberWhale image from the Middlebury database  [2]. In all of the presented experiments we used the trigonometric polynomial interpolator in real convention. A study of the impact of the choice of the trigonometric polynomial interpolator was made in  [5]  in a context of filtering. The experiments were made using an Intel(R) Core(TM) i7-7820HQ CPU.
3). We had again an initial discussion with her to present the training path, an interview after the first time she organized the training (Interview 2, 23 rd June 2017), and a second interview the second year she organized the training (Interview 3, 26 th February 2018). We also collected all the resources she used and produced. Using this data we filled in two documents tables: one for Rose as a teacher, and one for Rose as a facilitator. We submitted these two tables to Rose during a last interview (Interview 4, 26 th June 2018). She amended the tables and added some details and explanations, in particular declaring whether the operational invariants where usual or new. Drawing on these tables, we identified essential elements of documents developed by Rose: the aim of her activity, the resources she used for this aim, and the associated operational invariants.
The Chinese abacus comprises 13 vertical rods. Each rod corresponds to a rank of the place-value system: units, tens, hundreds, etc. There are several possibilities for displaying the same number. On the virtual abacus, the beads can be moved using the mouse. Three upper buttons allow users to display the number written in digits ("see number" button), represent the number using the least beads ("placement" button), or return to zero ("display zero" button). Complementing the virtual abacus, we also use a software called "j3p abacus". The j3p abacus can be used by a teacher for programming questions concerning two tasks: to set a number, or to read a number. The j3p software provides feedback with the right answer.
This is known as software back-annotation. Obtaining accurate estimates entails a two-fold strategy: retrieving precise non-functional information, usually at a basic block level granularity, by means of static or/and dynamic analysis (by re-creating the dynamic behavior of the target system using performance models of micro-architectural components such as caches, pipeline and branch predictor) and inserting this information at the right spot in the software. Accurate placement of annotations is the focus of this work. As for the retrieval of non-functional information, it is out of the scope of this paper. for(i = 0; i < N ; i ++) if (cond(x)) op1(x); else op2(x) return x; ILS (intermediate level simulation) has gained popularity in the performance estimation field (  [29] ,  [2] ,  [8] ) because it relies on the compiler intermediate representation (IR) as a functional model instead of the source code.
Thus, ILS is considered to be more accurate than source level simulation (SLS) because it comprises some compiler optimizations which makes it closer in its structure to the binary. However, the mapping between the control flow graphs (CFG, graphs in which vertices represent basic blocks and edges represent jumps between them), of the IR and of the binary is not always a straightforward task as discrepancies may appear between the two CFGs during the compiler's optimization passes. bb2 init() bb3 if (cond(x)) bb4 op1(x) bb5 op2(x) bb6 i -- if (i ≤ 0) bb7 return x bb2 init() bb3 if (cond(x)) bb4 op1(x) i -- if (i < 0) bb5 op2(x) i -- if (i < 0) bb6 return x a) C code b) IR CFG c) BIN CFG Fig. 1  illustrates a simple example of a C code compiled with gcc, using the optimization level O2, and its corresponding IR and binary CFGs.
Choice of the intermediate representation Due to compiler optimizations (branch optimizations, function inlining, loop otpimizations, etc. ), accurate annotation of the source code with low-level target-specific information is challenging. The discrepancy in the CFG structure between the source code and the binary, which may lead to estimation errors, is avoided by working on the IR code whose structure is very close to the binary CFG. 3. The final optimized file generated by the back-end right before assembly code generation is gcc-RTL 1. Thus, the RTL format is the closest to machine code as it encompasses machine-dependent optimizations. However, RTL is a very low-level IR that highly depends on the target architecture. On the other hand, there are the GCC Tree optimizer IRs which are generated before the RTL.
What interests us, is the last pass before RTL which is Gimple CFG generation (low-level Gimple Fig. 3 ) because it includes the last machine-independent optimizations. Gimple CFG is both source-language and target-machine independent. Our approach is compiler non-intrusive as we operate on the dump file of the compiler (GCC) and not on the internal structure. In fact, as GCC's internal modules are continually overhauled, introducing changes in the internal infrastructure of GCC (or any other compiler) is hard to maintain. The advantages of using such a representation are quite discernable in the example illustrated Fig. 5-a. Not only is the IR code very close in its syntax to C code but also the basic blocks are delimited and the CFG is already established. First, the source code is cross-compiled generating both the intermediate representation (IR-CFG), after high-level compiler optimization passes are performed, and the target binary (Fig.
The annotation framework overview Despite its easy-to-understand syntax, Gimple CFG is not compilable. So, we converted it into a compilable and optimized C code that maintains the CFG structure (uppermost flow Fig. 4 ). So, we developed a tool called GIMPLE-CFG-To-C that carries out the transformation of the IR to a particular compilable C code that preserves the functionality of the original source code but has an optimized structure (inherited from Gimple CFG) that exposes the basic block boundaries and accounts for the high-level optimizations. This is the only transformation applied on Gimple CFG before inserting the annotations. As for the binary, a CFG is recovered from it and nonfunctional information is extracted from each basic block of the binary CFG and stored in a basic block data base (lowermost flow Fig.
Experimentations Once compiler optimizations, both target dependent and independent, are reflected on the compilable Gimple CFG through accurate mapping, the insertion of annotations becomes straightforward. After the mapping has been carried out, the accuracy  of the estimations depends only on the precision of the extracted non-functional information. A fully-fledged software performance analysis is out of the scope of this article as the purpose of this work is to provide a precise mapping scheme, that along with an exhaustive performance analysis, yields accurate estimates. For the sake of validating our mapping scheme, we extracted information from the target binary CFG (as indicated Fig. 4 ) that corresponds to the original C code. As we can notice, a basic block data base is created, in which information of each basic block of the binary CFG is logged.
Perspectives Algorithm 1 is efficient at providing an accurate mapping between an IR CFG and its corresponding binary CFG compiled with the gcc O2 optimization level where the number of loops in the IR is identical to the one in the binary. The efficiency of the mapping algorithm is validated with the results showcased in Table  2. However, at the O3 optimization level, aggressive compiler optimizations such as loop unrolling are activated. As a reminder, loop unrolling is a compiler optimization that replicates the loop body UF (unrolling factor) times. The value of UF is chosen by the compiler based on the loop trip count. These optimizations can have a radical impact on the structure of the code and may lead in certain cases (eg. partial loop unrolling in the LLVM compiler Fig. 8-b ) to a different number of loops between the IR and the binary.
Fig. 8  shows the CFG of a simple program (consisting of the addition of two arrays inside a loop with an unknown trip count) at two different compilation stages: after machine-independent optimizations are performed (Fig. 8-a ) and after all (i. e. frontend and back-end) compiler optimizations are carried-out (Fig. 8 b was obtained using the LLVM compiler and Fig. 8 -c using gcc, with the highest level of optimizations enabled in both cases). Applying a first pass of Algorithm 1 (no recursion) on the IR CFG in Fig. 8 -a and its corresponding binary CFG obtained with the gcc compiler in Fig. 8-c   have no match in the IR). These unmapped basic blocks are the result of partial loop unrolling with an UF of 3. A transformation called peeling is performed by gcc during the loop unrolling optimization.
Introduction Electronic medical records (EMRs) contain essential information about the different symptomatic episodes a patient goes through. They have the potential to improve patient well-being and are therefore a potentially valuable source to artificial intelligence approaches. However, the linguistic variety as well as the tacit knowledge in EMRs can impair the prognosis of a machine learning algorithm. In this paper, we extract ontological knowledge from text fields contained in EMRs and evaluate the benefit when predicting hospitalization. Our study uses a dataset extracted from the PRIMEGE PACA relational database  [10]  which contains more than 350,000 consultations in French by 16 general practitioners (Table  1 ). In this database, text descriptions written by general practitioners are available with international classification codes of prescribed drugs, pathologies and reasons for consultations, as well as the numerical values of the different medical examination results obtained by a patient.
Our initial observation was that the knowledge available in a database such as PRIMEGE remains limited to the specificities of each patient and in particular that the texts found in there are based on a certain amount of implicit information known to medical experts. Moreover, the level of detail of the information contained in a patient's file is variable. Therefore, a machine learning algorithm exploiting solely the information at its disposal in an EMR will not be able to exploit this specific knowledge implicit in the documents it analyzes or, at best, it will have to relearn this knowledge by itself, possibly in an incomplete and costly way. In that context, our main research question is: Can ontological augmentations of the features improve the prediction of the occurrence of an event?.