No full-text available
To read the full-text of this research,
you can request a copy directly from the authors.
PATTERN BASED OBJECT ORIENTED SOFTWARE SYSTEMS DESIGN FOR HIGH PERFORMANCE COMPUTING
Abstract
Software patterns are reusable solutions for repeated software design problems. They are applied on object oriented software systems design. The patterns can be represented by suitable Unified Modeling Language -UML diagrams showing the structure of their class system and the interactions and relations amongst the class system members. Patterns can be identified by the solutions they offer in certain problems of certain contexts and can be grouped in categories according to the solutions they offer to broader problem and context areas. The two main categories are the architectural and the design patterns. The later consists of subcategories including fundamental, creational, structural, behavioral, concurrency and partitioning patterns. The individual patterns can be combined so as to offer complex solutions when necessary. Software patterns, which can be applied in the design of object oriented systems running on multiprocessors or cluster environments, are investigated in this paper.
... The larger the code, the longer the transfer time will be. In this sense, software engineering created techniques for reducing the size of JavaScript code, such as minification (Fountoukis and Chatzistavrou 2009). These techniques reduce the names of variables, methods, and objects, as well as remove white spaces and comments in excess. ...
Abstract Genetic Improvement is an area of Search Based Software Engineering that aims to apply evolutionary computing operators to the software source code to improve it according to one or more quality metrics. This article describes challenges related to experimental studies using Genetic Improvement in JavaScript (an interpreted and non-typed language). It describes our experience on performing a study with fifteen projects submitted to genetic improvement with the use of a supercomputer. The construction of specific software infrastructure to support such an experimentation environment reveals peculiarities (parallelization problems, management of threads, etc.) that must be carefully considered to avoid future research threats to validity such as dead-ends, which make it impossible to observe relevant phenomena (code transformation) to the understanding of software improvements and evolution.
According to a definition found in the summary of the Workshop on Adaptable and Adaptive Software[LL95]: "A program is called adaptive if it changes its behaviour automatically according to its context". Within this context, we restrict our research domain to the automatic runtime adaptation of existing behaviours. In this paper, we propose an Adaptive Strategy Design Pattern that can be used to analyze or design self-adaptive systems. It makes the significant components usually involved in a self-adaptive system explicit, and studies their interactions. We show how the components participate in the adaptation process, and characterize some of their properties.
Developing a distributed application is hard due to the complexity inherent to distributed communication. Moreover, distributed object communication technology is always changing, todays edge technology will become tomorrows legacy technology. This paper proposes an incremental approach to allow a divide and conquer strategy that copes with these problems. It presents a design pattern for distributed object communication. The proposed solution decouples distributed object communication from object specific functionalities. It further decouples logical communication from physical communication. The solution enforces an incremental development process and encapsulates the underlying distribution mechanisms. The paper uses a stage-based design description which allow design description at a different level of abstraction than code.
Computational biology research is now faced with the burgeoning number of genome data. The rigorous post- processing of this data requires an increased role for high performance computing (HPC). Because the development of HPC applications for computational biology problems is much more complex than the corresponding sequen- tial applications, existing traditional programming tech- niques have demonstrated their inadequacy. Many high level programming techniques, such as skeleton and pattern based programming, have therefore been designed to pro- vide users new ways to get HPC applications without much effort. However, most of them remain absent from the main- stream practice for computational biology. In this paper, we present a new parallel pattern-based system prototype for computational biology. The underlying programming tech- niques are based on generic programming, a programming technique suited for the generic representation of abstract concepts. This allows the system to be built in a generic way at application level and thus provides good extensibil- ity and flexibility. We show how this system can be used to develop HPC applications for popular computational biol- ogy algorithms and lead to significant runtime savings on distributed memory architectures.
Formal ontology has proved to be an extremely useful tool for negotiating intended meaning, for building explicit, formal data sheets, and for the discovery of novel views on existing data structures. This paper describes an example of application of formal ontological methods to the creation of biomedical ontologies. Addressed here is the ambiguous notion of inflammation, which spans across multiple linguistic meanings, multiple layers of reality, and multiple details of granularity. We use UML class diagrams, description logics, and the DOLCE foundational ontology, augmented with the Description and Situation theory, in order to provide the representational and ontological primitives that are necessary for the development of detailed, flexible, and functional biomedical ontologies. An ontology design pattern is proposed as a modelling template for inflammations.
Software patterns express a generic solution for a specific design problem, conveying some knowledge and expertise from designers. Model checking is an automatic technique for verifying finite state systems that determines if a property holds of the given finite state machine. The paper describes the experience of the authors in modeling three concurrency design patterns using the Bandera toolset for model checking. The concurrency properties of these patterns were specified using the BASL language and submitted for checking after the relaxation of the code. Due to some problems related to the immaturity of the tool, only one model could be checked, in one special property. The main contribution of the paper is the formalization of the patterns and the sequence of steps followed in order to formalize and check these patterns. Key Words: Pattern verification, Design Patterns, Model Checking, Software Specification. 1.
This paper describes the Active Object pattern, which decou- ples method execution from method invocation in order to simplify synchronized access to a shared resource by meth- ods invoked in different threads of control. The Active Object pattern allows one or more independent threads of execution to interleave their access to data modeled as a single ob- ject. A broad class of producer/consumer and reader/writer problems are well-suited to this model of concurrency. This pattern is commonly used in distributed systems requiring multi-threaded servers. In addition, client applications (such as windowing systems and network browsers), are increas- ingly employing active objects to simplify concurrent, asyn- chronous network operations.
From the Publisher:In-depth coverage of forty-seven Java design patterns Since the publication of the first edition in 1998, programmers and developers have been waiting eagerly for an update to this expert guide on how to use Java in conjunction with the timesaving design patterns that have surfaced in the past few years. With the new edition of his bestselling Patterns in Java, Volume 1, Mark Grand brings you up to date with the latest release of Java and many of the important concerns facing Java programmers today.If you are a programmer or developer who wants to take advantage of new patterns, but doesnt have the time or experience to document them for your organization, this book is for you. As with the first edition, each pattern is documented in UML and, where appropriate, a code example or an example in the core Java API is provided. This comprehensive book gives you:Seven fundamental design patternsSix creational patternsThree partitioning patternsNine structural patternsEleven behavioral patternsEleven concurrency patternsUML documentation of all 47 patternsPractical, hands-on examples of pattern implementation in JavaThe companion Web site containing all of the Java source code and UML models from the book.Author Biography: MARK GRAND is an Atlanta-based consultant with over twenty-three years of experience in distributed systems, object-oriented design, and Java. He is currently working on an open source framework for gluing components and programs into an application. He is also the author of Patterns in Java, Volume 2 and Java Enterprise Design Patterns (both from Wiley).
In an increasing number of application domains, dispatch-ing components are responsible for delivering upcalls to one or more application objects when events or requests arrive in a system. Implementing efficient, predictable, and scal-able dispatching components is hard and implementing them for multi-threaded systems is even harder. In particular, dis-patching components must be prepared to deliver upcalls to multiple objects, to handle recursive requests originated from application-provided upcalls, and often must collaborate with applications to control object life-cycles. In our distributed object computing (DOC) middleware re-search, we have implemented many dispatching components that apply common solutions repeatedly to solve the chal-lenges outlined above. Moreover, we have discovered that the forces constraining dispatching components often differ slightly, thereby requiring alternative solution strategies. This paper presents two contributions to the design and implemen-tation of efficient, predictable, scalable, and flexible dispatch-ing components. First, it shows how patterns can be ap-plied to capture key design and performance characteristics of proven dispatching components. Second, it presents a set of patterns that describe successful solutions appropriate for key dispatching challenges arising in various real-time DOC middleware and applications.
Reliable distributed systems involve many complex protocols. In this context, protocol composition is a central concept, because it allows the reuse of robust protocol implementations. In this paper, we describe how the Strategy pattern has been recursively used to support protocol composition in the BAST framework. We also discuss design alternatives that have been applied in other existing frameworks.
In this paper we propose a hybrid physical/simulation environment for benchmarking real-time distributed control systems.
This environment uses Arena® Real Time for simulation and the Java-based TINI platform for real-time control. The paper focuses
on the development of a software design pattern for client-server communication.
The concept of design patterns has been extensively studied and applied in the context of object-oriented software design. Similar ideas are being explored in other areas of computing as well. Over the past several years, researchers have been experimenting with the feasibility of employing design-patterns related concepts in the parallel computing domain. In the past, several pattern-based systems have been developed with the intention to facilitate faster parallel application development through the use of pre-implemented and reusable components that are based on frequently used parallel computing design patterns. However, most of these systems face several serious limitations such as limited flexibility, zero extensibility, and ad hoc nature of their components. Lack of flexibility in a parallel programming system limits a programmer to using only the high-level components provided by the system. Lack of extensibility here refers to the fact that most of the existing pattern- based parallel programming systems come with a set of pre-built patterns integrated into the system. However, the system provides no obvious way of increasing the repertoire of patterns when need arises. Also, most of these systems do not offer any generic view of a parallel computing pattern, a fact which may be at the root of several of their shortcomings. This research proposes a generic (i.e., pattern- and application-independent) model for realizing and using parallel design patterns. The term "Parallel Architectural Skeleton" is used to represent the set of generic attributes associated with a pattern. The Parallel Architectural Skeleton Model (PASM) is based on the message-passing paradigm, which makes it suitable for a LAN of workstations and PCs. The model is flexible as it allows the intermixing of high- level patterns with low-level message-passing primitives. An object-oriented and library-based implementation of the model has been completed using C++ and MPI, without necessitating any language extension. The generic model and the library-based implementation allow new patterns to be defined and included into the system. The skeleton-library serves as a "framework" for the systematic, hierarchical development of network-oriented parallel applications.
The book is an introduction to the idea of design patterns in software engineering, and a catalog of twenty-three common patterns. The nice thing is, most experienced OOP designers will find out they've known about patterns all along. It's just that they've never considered them as such, or tried to centralize the idea behind a given pattern so that it will be easily reusable.
Design patterns help to improve communication software quality since they address a fundamental challenge in largescale software development: communication of architectural knowledge among developers. This paper makes several contributions to the study and practice of design patterns. It presents a case study that illustrates how design patterns helped to reduce development effort and project risk when evolving an object-oriented telecommunication software framework across UNIX and WindowsNTOSplatforms. Second, the paper discusses the techniques, benefits, and limitations of applying a design pattern-based reuse strategy to commercial telecommunication software systems. 1 Introduction Developing communication software that is reusable across OS platforms is hard. Constraints imposed by the underlying OS platforms may make it impractical to reuse existing algorithms, detailed designs, interfaces, or implementations directly. This paper describes how we evolved an object-oriented frame...
This paper describes the Active Object pattern, which decouples method execution from method invocation in order to simplify synchronized access to an object that resides in its own thread of control. The Active Object pattern allows one or more independent threads of execution to interleave their access to data modeled as a single object. A broad class of producer/consumer and reader/writer applications are wellsuited to this model of concurrency. This pattern is commonly used in distributed systems requiring multi-threaded servers. In addition, client applications, such as windowing systems and network browsers, employ active objects to simplify concurrent, asynchronous network operations. 1 Intent The Active Object design pattern decouples method execution from method invocation to enhance concurrency and simplify synchronized access to an object that resides in its own thread of control. 2 Also Known As Concurrent Object and Actor 3 Example To illustrate the Active Object patter...
This paper will appear in the C++ Report magazine. 1 Introduction
Applying Patterns to Meet the Challenges of Concurrent Software, Invited contribution to the IEEE Concurrency to the
- C Douglas
- Schmidt
Douglas C. Schmidt, (1997), Applying Patterns to Meet the Challenges
of Concurrent Software, Invited contribution to the IEEE Concurrency to
the IEEE Concurrency Special Edition on Software Engineering for
Parallel and Distributed Systems, Vol. 5, No. 3, Fall 1997.
Modelling, Simulation and Optimization of Complex Processes
- M Hoang
- Song
Hoang M. Song, (2006), Modelling, Simulation and Optimization of
Complex Processes, Proceedings of the Third International Conference on
High Performance Scientific Computing, March 6-10, 2006, Hanoi,
Vietnam.
Distributed Proxy: A Design Pattern for the Incremental Development of Distributed Applications
- Antonio Rito Silva
Antonio Rito Silva, Francisco Assis Rosa, Teresa Gonc¸ Alves and
Miguel Antunes, (2001), Distributed Proxy: A Design Pattern for the
Incremental Development of Distributed Applications, Springer Berlin /
Heidelberg, pp. 165-181.