Extending UML templates towards flexibility

UML templates are generic model elements that may be instantiated as domain specific solutions by means of parameterization. Some of the elements in a template definition are marked as parameters, implying that these must be sub-stituted by elements of the domain model, so to get a fully functional instance of the template. On parameter substitutions, UML enforces that the parame-tered element and its substitute must be of the same kind (both classes, both at-tributes, etc.). This paper shows that this constraint confines the applicability of templates and proposes an alternative that, by allowing substitutions among elements of different kinds, broadens that applicability. Cross-kind substitu-tions, however, require adequate semantics for the Binding relationship. Such semantics are proposed as model transformations that must complement the plain substitutions preconized by UML. Examples of such transformations are provided for activities in a template being expanded into a bound element.info:eu-repo/semantics/publishedVersio

A demonstration of compilability for UML template instances

Because of the thin set of well-formedness rules associated to Templates in UML, ill-formed elements may result from bindings to templates. Although such ill-formedness is generally detected by some UML validation rule, the problem is poorly reported because it is not normally imputed to the binding. Typically, such problems are detected as non-compilable code in the template instances. A set of well-formedness rules, additional to those of the standard UML, was proposed as a way to ensure the compilability of instances and prevent this problem from occurring. Such set of constraints was proposed in a previous paper and named Functional Conformance, but a demonstration of its effectiveness was not yet provided. Such a demonstration is outlined in the current paper. Carrying out the demonstration revealed the need for two more rules than those previously envisioned for Functional Conformance.info:eu-repo/semantics/acceptedVersio

Extending UML templates towards flexibility (extended version)

Extended version of a research paper submitted to the 2nd Flexible MDE Workshop, FlexMDE 2016 (www.di.univaq.it/flexmde/).UML templates are generic model elements that may be instantiated as domain specific solutions by means of parameterization. Some of the elements in a tem-plate definition are marked as parameters, which must be substituted by conform-ing elements in the domain model to get a fully functional instance of the tem-plate. The validation of parameter substitutions enforces that the parametered ele-ment and its substitute must be of the same kind (both classes, both attributes, etc.). This paper shows that such imperative restrains the applicability of tem-plates and proposes an alternative set of constraints that, by allowing substitu-tions among elements of different kinds, widens that applicability. Cross-kind substitutions, however, require adequate semantics for the Binding relationship. Such semantics are proposed as model transformations that must complement the plain substitutions preconized by UML and are exemplified w.r.t. the instantiation of activity diagrams

Xcd - Modular, Realizable Software Architectures

Connector-Centric Design (Xcd) is centred around a new formal architectural description language, focusing mainly on complex connectors. Inspired by Wright and BIP, Xcd aims to cleanly separate in a modular manner the high-level functional, interaction, and control system behaviours. This can aid in both increasing the understandability of architectural specifications and the reusability of components and connectors themselves. Through the independent specification of control behaviours, Xcd allows designers to experiment more easily with different design decisions early on, without having to modify the functional behaviour specifications (components) or the interaction ones(connectors). At the same time Xcd attempts to ease the architectural specification by following (and extending) a Design-by-Contract approach, which is more familiar to software developers than process algebras like CSP or languages like BIP that are closer to synchronous/hardware specification languages. Xcd extends Design-by-Contract (i) by separating component contracts into functional and interaction sub-contracts, and (ii) by allowing service consumers to specify their own contractual clauses. Xcd connector specifications are completely decentralized, foregoing Wright’s connector glue, to ensure their realizability by construction

Formal Language Recognition with the Java Type Checker

This paper is a theoretical study of a practical problem: the automatic generation of Java Fluent APIs from their specification. We explain why the problem\u27s core lies with the expressive power of Java generics. Our main result is that automatic generation is possible whenever the specification is an instance of the set of deterministic context-free languages, a set which contains most "practical" languages. Other contributions include a collection of techniques and idioms of the limited meta-programming possible with Java generics, and an empirical measurement demonstrating that the runtime of the "javac" compiler of Java may be exponential in the program\u27s length, even for programs composed of a handful of lines and which do not rely on overly complex use of generics

Tool Support For Axiomatic Programming

Many problems arising from spectacular error messages involving C++ templates are related to the fact that assumptions made by the C++ standard algorithms are stated in informal comments, not in code that is checked by the compiler. Some of those properties are syntactic, meaning that the compiler can do syntax and type checking and reject erroneous constructs. Others are semantics, e.g. that a type is regular. Such assumptions can be checked only if programmers have ways to express those assumptions in code. My project proposes to augment a subset of C++ with concepts and axioms that would let programmers express semantics requirements

Search-based system architecture development using a holistic modeling approach

This dissertation presents an innovative approach to system architecting where search algorithms are used to explore design trade space for good architecture alternatives. Such an approach is achieved by integrating certain model construction, alternative generation, simulation, and assessment processes into a coherent and automated framework. This framework is facilitated by a holistic modeling approach that combines the capabilities of Object Process Methodology (OPM), Colored Petri Net (CPN), and feature model. The resultant holistic model can not only capture the structural, behavioral, and dynamic aspects of a system, allowing simulation and strong analysis methods to be applied, it can also specify the architectural design space. Both object-oriented analysis and design (OOA/D) and domain engineering were exploited to capture design variables and their domains and define architecture generation operations. A fully realized framework (with genetic algorithms as the search algorithm) was developed. Both the proposed framework and its suggested implementation, including the proposed holistic modeling approach and architecture alternative generation operations, are generic. They are targeted at systems that can be specified using object-oriented or process-oriented paradigm. The broad applicability of the proposed approach is demonstrated on two examples. One is the configuration of reconfigurable manufacturing systems (RMSs) under multi-objective optimization and the other is the architecture design of a manned lunar landing system for the Apollo program. The test results show that the proposed approach can cover a huge number of architecture alternatives and support the assessment of several performance measures. A set of quality results was obtained after running the optimization algorithm following the proposed framework --Abstract, page iii

Exploring Hardware Agnostic Multiarrays in Magnolia

We present a specification and implementation of a generic multiarray API based on A Mathematics of Arrays in the general purpose research language Magnolia. We show how we can lift the reasoning on arrays to a more abstract level, and how this enables us to precisely manipulate arrays independent of hardware memory layouts.Masteroppgave i informatikkINF399MAMN-PROGMAMN-IN

Programming Language Evolution and Source Code Rejuvenation

Programmers rely on programming idioms, design patterns, and workaround techniques to express fundamental design not directly supported by the language. Evolving languages often address frequently encountered problems by adding language and library support to subsequent releases. By using new features, programmers can express their intent more directly. As new concerns, such as parallelism or security, arise, early idioms and language facilities can become serious liabilities. Modern code sometimes bene fits from optimization techniques not feasible for code that uses less expressive constructs. Manual source code migration is expensive, time-consuming, and prone to errors. This dissertation discusses the introduction of new language features and libraries, exemplifi ed by open-methods and a non-blocking growable array library. We describe the relationship of open-methods to various alternative implementation techniques. The benefi ts of open-methods materialize in simpler code, better performance, and similar memory footprint when compared to using alternative implementation techniques. Based on these findings, we develop the notion of source code rejuvenation, the automated migration of legacy code. Source code rejuvenation leverages enhanced program language and library facilities by finding and replacing coding patterns that can be expressed through higher-level software abstractions. Raising the level of abstraction improves code quality by lowering software entropy. In conjunction with extensions to programming languages, source code rejuvenation o ers an evolutionary trajectory towards more reliable, more secure, and better performing code. We describe the tools that allow us efficient implementations of code rejuvenations. The Pivot source-to-source translation infrastructure and its traversal mechanism forms the core of our machinery. In order to free programmers from representation details, we use a light-weight pattern matching generator that turns a C like input language into pattern matching code. The generated code integrates seamlessly with the rest of the analysis framework. We utilize the framework to build analysis systems that find common workaround techniques for designated language extensions of C 0x (e.g., initializer lists). Moreover, we describe a novel system (TACE | template analysis and concept extraction) for the analysis of uninstantiated template code. Our tool automatically extracts requirements from the body of template functions. TACE helps programmers understand the requirements that their code de facto imposes on arguments and compare those de facto requirements to formal and informal specifications