Synthesizing Program Input Grammars

We present an algorithm for synthesizing a context-free grammar encoding the language of valid program inputs from a set of input examples and blackbox access to the program. Our algorithm addresses shortcomings of existing grammar inference algorithms, which both severely overgeneralize and are prohibitively slow. Our implementation, GLADE, leverages the grammar synthesized by our algorithm to fuzz test programs with structured inputs. We show that GLADE substantially increases the incremental coverage on valid inputs compared to two baseline fuzzers

Monitoring-Oriented Programming: A Tool-Supported Methodology for Higher Quality Object-Oriented Software

This paper presents a tool-supported methodological paradigm for object-oriented software development, called monitoring-oriented programming and abbreviated MOP, in which runtime monitoring is a basic software design principle. The general idea underlying MOP is that software developers insert specifications in their code via annotations. Actual monitoring code is automatically synthesized from these annotations before compilation and integrated at appropriate places in the program, according to user-defined configuration attributes. This way, the specification is checked at runtime against the implementation. Moreover, violations and/or validations of specifications can trigger user-defined code at any points in the program, in particular recovery code, outputting or sending messages, or raising exceptions. The MOP paradigm does not promote or enforce any specific formalism to specify requirements: it allows the users to plug-in their favorite or domain-specific specification formalisms via logic plug-in modules. There are two major technical challenges that MOP supporting tools unavoidably face: monitor synthesis and monitor integration. The former is heavily dependent on the specification formalism and comes as part of the corresponding logic plug-in, while the latter is uniform for all specification formalisms and depends only on the target programming language. An experimental prototype tool, called Java-MOP, is also discussed, which currently supports most but not all of the desired MOP features. MOP aims at reducing the gap between formal specification and implementation, by integrating the two and allowing them together to form a system

Methods and apparatus for constructing and implementing a universal extension module for processing objects in a database

Methods and apparatus for providing a multi-tier object-relational database architecture are disclosed. In one illustrative embodiment of the present invention, a multi-tier database architecture comprises an object-relational database engine as a top tier, one or more domain-specific extension modules as a bottom tier, and one or more universal extension modules as a middle tier. The individual extension modules of the bottom tier operationally connect with the one or more universal extension modules which, themselves, operationally connect with the database engine. The domain-specific extension modules preferably provide such functions as search, index, and retrieval services of images, video, audio, time series, web pages, text, XML, spatial data, etc. The domain-specific extension modules may include one or more IBM DB2 extenders, Oracle data cartridges and/or Informix datablades, although other domain-specific extension modules may be used

Optimization Coaching for JavaScript

The performance of dynamic object-oriented programming languages such as JavaScript depends heavily on highly optimizing just-in-time compilers. Such compilers, like all compilers, can silently fall back to generating conservative, low-performance code during optimization. As a result, programmers may inadvertently cause performance issues on users\u27 systems by making seemingly inoffensive changes to programs. This paper shows how to solve the problem of silent optimization failures. It specifically explains how to create a so-called optimization coach for an object-oriented just-in-time-compiled programming language. The development and evaluation build on the SpiderMonkey JavaScript engine, but the results should generalize to a variety of similar platforms

The use of computer-interpretable clinical guidelines to manage care complexities of patients with multimorbid conditions : a review

Clinical practice guidelines (CPGs) document evidence-based information and recommendations on treatment and management of conditions. CPGs usually focus on management of a single condition; however, in many cases a patient will be at the centre of multiple health conditions (multimorbidity). Multiple CPGs need to be followed in parallel, each managing a separate condition, which often results in instructions that may interact with each other, such as conflicts in medication. Furthermore, the impetus to deliver customised care based on patient-specific information, results in the need to be able to offer guidelines in an integrated manner, identifying and managing their interactions. In recent years, CPGs have been formatted as computer-interpretable guidelines (CIGs). This enables developing CIG-driven clinical decision support systems (CDSSs), which allow the development of IT applications that contribute to the systematic and reliable management of multiple guidelines. This study focuses on understanding the use of CIG-based CDSSs, in order to manage care complexities of patients with multimorbidity. The literature between 2011 and 2017 is reviewed, which covers: (a) the challenges and barriers in the care of multimorbid patients, (b) the role of CIGs in CDSS augmented delivery of care, and (c) the approaches to alleviating care complexities of multimorbid patients. Generating integrated care plans, detecting and resolving adverse interactions between treatments and medications, dealing with temporal constraints in care steps, supporting patient-caregiver shared decision making and maintaining the continuity of care are some of the approaches that are enabled using a CIG-based CDSS