Applying reflection in object-oriented software design

thesis work performs a series of experiments on applying reflection technique to improve software design. First, a REFLECTIVE V ISITOR pattern was captured to improve the traditional VISITOR pattern. Reflection enables a visitor to perform a run-time dispatch action on itself. The cyclic dependencies between the visitor structure and the element structure are broken, thus both of them can be reused independently. Secondly, a parser framework was developed by applying several patterns. Especially, the REFLECTION pattern is used in the design of dynamically handling a parsing process by separating the system into two levels. The base-level defines the grammar rules. The meta-level handles the complex relationships of these rules. Reflection technique is used to discover grammar rules at run-time and determines the parsing order. Third, a dynamic object model was defined for a virtual machine that can support reflection. We demonstrated Forman's theory by developing a simplified object model based on a single inheritance system with the support of only one metaclass. Finally, an extensible and reusable compiler system (front-end) for the Decaf programming language was designed and implemented

Overlapping dialogues: the role of interpretation design in communicating Australia’s natural and cultural heritage

This research investigates the development of interpretation design in Australia during the period 1980 – 2006, and its role in presenting natural and cultural heritage to audiences in visitor settings. It establishes Australian interpretation design at the intersection of two professional fields, interpretation and design. Where heritage interpretation originates from a background of spoken language, through narrative and storytelling, graphic and communication design have origins in visual language, communicated through images and text. This research positions interpretation design as a new field within design and traces its emergence as a hybrid of spoken and visual traditions of communication.The study gives visibility to this previously undocumented and un-theorised hybrid field of design and creates a thematic conceptual framework within which to locate its historical, conceptual and practical origins. In substantiating interpretation design as a new field, three avenues of enquiry were considered; documentation and analysis of the visual artefacts of interpretation design, locating interpretation design in a wider conceptual and professional context through literature reviews, and consultation with designers in order to understand the challenges and problems in this new mode of design. Further, to facilitate designers to continue to work effectively in highly collaborative, complex and cross-disciplinary professional environments a conceptual collaborative tool was developed for use by interpretation design project teams. The conceptual tool integrates the theoretical and practical findings from this research and is based on a pattern language approach first developed by Christopher Alexander et al (1977).The research is conducted from a design perspective, and integrates theoretical and professional knowledge from related fields into interpretation design practice. Through a progressively widening interrogation of the literature, professional contexts, and designed artefacts of interpretation design, this new area of design is examined from a number of perspectives, building up a multi-faceted framework for understanding its historical, conceptual and practical dimensions. A Grounded Theory methodology was adapted to develop the theoretical framework of this study and to gather a wide range of relevant data. The practical outcome of the research was developed using a Pattern Language methodology originating from a problem-based design approach in architecture (Alexander et al 1977) and underpinned the interpretation of data.Conclusions of the research found that despite invisibility within the discourse of Australian design, designers working in this specialised field of practice have, since the early 1980s, contributed to projects which shape ideas, attitudes and visual representations of natural and cultural heritage in Australia’s most widely visited and valued sites. Designer’s practice is identified as part of an ongoing process of both contributing to Australian cultural narrative and being influenced by the legacy of culture. Contemporary interpretation design is highly cross-disciplinary and collaborative, characterised by a differentiated professional practice with dispersed networks of stakeholders. While interpretation design is located within a larger framework of the professional practice of interpretation, there exists many opportunities to enrich and better inform designers by integrating wider pools of knowledge that intersect the activities of interpretation, including education, tourism, visitor studies and psychology

Object-Oriented Paradigms for Modelling Vascular\ud Tumour Growth: a Case Study

Motivated by a family of related hybrid multiscale models, we have built an object-oriented framework for developing and implementing multiscale models of vascular tumour growth. The models are implemented in our framework as a case study to highlight how object-oriented programming techniques and good object-oriented design may be used effectively to develop hybrid multiscale models of vascular tumour growth. The intention is that this paper will serve as a useful reference for researchers modelling complex biological systems and that these researchers will employ some of the techniques presented herein in their own projects

Invertible Program Restructurings for Continuing Modular Maintenance

When one chooses a main axis of structural decompostion for a software, such as function- or data-oriented decompositions, the other axes become secondary, which can be harmful when one of these secondary axes becomes of main importance. This is called the tyranny of the dominant decomposition. In the context of modular extension, this problem is known as the Expression Problem and has found many solutions, but few solutions have been proposed in a larger context of modular maintenance. We solve the tyranny of the dominant decomposition in maintenance with invertible program transformations. We illustrate this on the typical Expression Problem example. We also report our experiments with Java and Haskell programs and discuss the open problems with our approach.Comment: 6 pages, Early Research Achievements Track; 16th European Conference on Software Maintenance and Reengineering (CSMR 2012), Szeged : Hungary (2012

Designing Expression Templates with Concepts

International audienceConcepts are likely to be introduced in a future C++ standard. They can be used for constraining template parameters, which enables checking requirements on template parameters sooner in the compilation process, and thus providing more intelligible error messages to the user.They can also be used in the specialization of templates, thus leading to a better control over the selection of the most appropriate version of a template for a given instantiation. This latter aspect offers new possibilities in the design of template libraries, as it enhances the specialization mechanism of templates, and set it up as a solid alternative to inheritance when static binding can replace dynamic binding.This report addresses the design of expression templates (i.e. templates that represent expressions and are usually built through operator overloading) that are useful to develop an embedded domain specific language (EDSL), and can speed up the evaluation of an expression by delaying the evaluation of intermediate operations to avoid unnecessary temporary objects.We propose to use concept-based template specialization to parse expression templates in order to ease the design of an EDSL. This approach is a static variant of the well-known visitor design pattern that replaces the overridden methods in the double dispatch of the original design pattern by template specializations based on concepts. An example of EDSL for linear programming developed with our solution demonstrates that a concept-based design helps producing concise and reliable code

A Case for Custom, Composable Composition Operators

Programming languages typically support a fixed set of com- position operators, with fixed semantics. This may impose limits on software designers, in case a desired operator or semantics are not supported by a language, resulting in suboptimal quality characteristics of the designed software system. We demonstrate this using the well-known State design pattern, and propose the use of a composition infrastructure that allows the designer to define custom, composable composition operators. We demonstrate how this approach improves several quality factors of the State design pattern, such as reusability and modularity, while taking a reason- able amount of effort to define the necessary pattern-related code

Towards an aspect weaving BPEL engine

This position paper proposes the use of dynamic aspects and the visitor design pattern to obtain a highly configurable and extensible BPEL engine. Using these two techniques, the core of this infrastructural software can be customised to meet new requirements and add features such as debugging, execution monitoring, or changing to another Web Service selection policy. Additionally, it can easily be extended to cope with customer-specific BPEL extensions. We propose the use of dynamic aspects not only on the engine itself but also on the workflow in order to tackle the problems of Web Service hot deployment and hot fixes to long running processes. In this way, composing aWeb Service "on-the-fly" means weaving its choreography interface into the workflow

Pattern-based model transformation: a metamodel-based approach to model evolution

Software systems continue to grow in complexity at a rapid pace, creating systems that are complex to build and evolve. The problems that accompany changes in requirements, system upgrades, and error correction produce a desire for software evolution methods that increase the efficiency and effectiveness of adapting complex software to changes. As software systems evolve, design models must be modified to accommodate the required changes. Techniques that control the changes to models in a systematic manner are a key to model evolution. A process that improves the ability to effectively modify a design, thereby enhancing design qualities, supports the need for improved model evolution techniques. Design patterns are common forms of reusable design experiences. They offer solutions to common design problems, reduce complexity by naming and defining abstractions, and provide a foundation for building reusable software. Well-known pattern solutions are expressed in a natural language as fragments of code which are sometimes difficult to understand and implement by software modelers. With increased focus on development of model-driven approaches, rigorous descriptions of design patterns that capture solutions during design instead of implementation are needed. This research defines an approach for the transformation of models that supports controlled model evolution. More precisely, a process for capturing design patterns in UML class diagrams is defined. This process involves defining a metamodel-level representation which specifies how a software developer can introduce design patterns into existing design models. We defined transformation patterns as an extension of the UML metamodel to characterize source and target model elements. The transformation pattern consists of specialized metamodel elements that specify the structure of source and target metamodels. Transformation patterns were specified for the Abstract Factory, Bridge and Visitor design patterns to show how the model-level transformations can be perform on patterns that represent different functionalities. We developed an action language to specify constructs which add, delete, retrieve and connect model elements. We used the constructs of the action language to define transformation specifications that implement model-level transformations on class diagrams. To determine the potential of this approach we manually implemented the transformation specification on a UML design