Instrumenting contracts with aspect-oriented programming to increase observability and support debugging

In this paper we report on how Aspect-Oriented Programming (AOP), using AspectJ, can be employed to automatically and efficiently instrument contracts and invariants in Java, The paper focuses on the templates to instrument preconditions, postconditions, and class invariants, and the necessary instrumentation for compliance-checking to the Liskov Substitution Principle

Lessons learned from developing a dynamic OCL constraint enforcement tool for java

Analysis and design by contract allows the definition of a formal agreement between a class and its clients, expressing each party's rights and obligations. Contracts written in the Object Constraint Language (OCL) are known to be a useful technique to specify the precondition and postcondition of operations and class invariants in a UML context, making the definition of object-oriented analysis or design elements more precise while also helping in testing and debugging. In this article, we report on the experiences with the development of ocl2j, a tool that automatically instruments OCL constraints in Java programs using aspect-oriented programming (AOP). The approach strives for automatic and efficient generation of contract code, and a non-intrusive instrumentation technique. A summary of our approach is given along with the results of an initial case study, the discussion of encountered problems, and the necessary future work to resolve the encountered issues

Fine-grained semi-automated runtime evolution

Modern software systems that play critical roles in society are often required to change at runtime so that they can continuously provide essential services in the dynamic environments they operate in. Updating open, distributed software systems at runtime is very challenging. Using runtime models as an interface for updating software at runtime can help developers manage the complexity of updating software while it is executing. In this chapter we describe an approach to updating Java software at runtime through the use of runtime models consisting of UML class and sequence diagrams. Changes to models are transformed to changes on Java source code, which is then propagated to the runtime system using the JavAdaptor technology. In particular, the presented approach permits in-the-small software changes, i.e., changes at the code statement level, as opposed to in-the-large changes, i.e., changes at the component level. We present a case study that demonstrates the major aspects of the approach and its use. We also give the results of a preliminary evaluation of the approach

Constraint Support in MDA tools: a Survey

Abstract: The growing interest in the MDA (Model-Driven Architecture) and MDD (Model-Driven Development) approaches has largely increased the number of tools and methods including code-generation capabilities. Given a platform-independent model (PIM) of an application, these tools generate (part of) the application code either by defining first a platform-specific model or by executing a direct PIM to code transformation. However, current tools present several limitations regarding code generation of the integrity constraints defined in the PIMs. This paper compares these tools and shows that they lack expressiveness in the kind of constraints they can handle or efficiency in the code generated to verify them. Based on this evaluation, the features of an ideal code-generation method for integrity constraints are established. We believe such a method is required to extend MDA adoption in the development of industrial projects, where constraints play a key role. 1

Probing for structural motion and cooperativity during the PRMT catalytic cycle

Protein arginine methyltransferases (PRMTs) are homodimeric enzymes which are responsible for regulating the expression of genes and the activity of other proteins in humans and other organisms, by transferring a methyl group from S-adenosyl-methionine (SAM) to the terminal guanidino nitrogen atoms of protein arginine residues. PRMT1 is the major producer of methylated arginine in the human body. The homodimer of PRMT1 possess two active sites, each of which appear identical in crystal structures and are therefore both likely able to methylate substrates. Both active sites are obstructed by an N-terminal helical region of each respective monomer, which likely regulates the binding of both the methyl donor SAM, and the arginine containing peptide substrate. In order to observe both the motion in the N-terminal region and observe any potential cooperativity between monomers we would like to be able to selectively label only one N-terminus within a dimer, or knock out activity in one active site. We will achieve this by creating a single polypeptide harboring the sequence of two PRMT1 monomers connected by a short amino acid linker. This linked-PRMT construct (PRMT1-linker-PRMT1) will allow us to selectively label desired positions on only one part of a monomer, such as an active site, along with mutating or truncating one N-terminus at a time. This new construct will allow us to place a fluorophore at only one N-terminus so that we can observe the motion at one active site, while specific mutations or truncations can give us insight into the regulatory role of particular residues or interactions. These new constructs will also allow us to make point mutations in one active site of the dimeric enzyme in order to evaluate the suspected dynamics and cooperativity that occur in PRMT1

From Declarative to Imperative UML/OCL Operation Specifications

An information system maintains a representation of the state of the domain in its Information Base (IB). The state of the IB changes due to the execution of the operations defined in the behavioral schema. There are two different approaches for specifying the effect of an operation: the imperative and the declarative approaches. In conceptual modeling, the declarative approach is preferable since it allows a more abstract and concise definition of the operation effect and conceals all implementation issues. Nevertheless, in order to execute the conceptual schema, declarative specifications must be transformed into equivalent imperative ones. Unfortunately, declarative specifications may be non-deterministic. This implies that there may be several equivalent imperative versions for the same declarative specification, which hampers the transformation process. The main goal of this paper is to provide a pattern-based translation method between both specification approaches. To facilitate the translation we propose some heuristics that improve the precision of declarative specifications and help avoid non-determinism in the translation process