Skip to main content

2010 | Buch

Autonomics Development: A Domain-Specific Aspect Language Approach

insite
SUCHEN

Über dieses Buch

Distributed applications are difficult to write as programmers need to adhere to specific distributed systems programming conventions and frameworks, which makes distributed systems development complex and error prone and ties the resultant application to the distributed system because the application's code is tangled with the crosscutting concern distribution. This book introduces the concept of a domain-specific aspect language called a Distribution Definition Language that generalises the distribution and distribution recovery concerns by describing the classes and methods of an existing application to be made remote, the distributed system to use to make them remote and the recovery mechanism to use in the event of an error. A software tool in the form of the RemoteJ compiler/generator that uses information contained in the Distribution Definition Language to generate the recovery and distributed system specific code and apply it to the application using bytecode manipulation and generation techniques is introduced. By allowing distribution and autonomic features, such as recovery, to be modularised and applied to existing applications this approach greatly simplifies distributed systems and autonomics development. This book is of particular interest to researchers and students of distributed systems, autonomics, domain-specific aspect languages and aspect-orientation.

Inhaltsverzeichnis

Frontmatter
1. Introduction
Abstract
The widespread adoption of the Internet and associated technologies has resulted in a huge increase in the number of distributed systems, both Internet and Intranet facing. Numerous legacy systems have been, or are being, adapted to provide an Internet presence and to integrate to customers’ and suppliers’ systems. In addition, faster and more reliable networks have greatly contributed to the success of distributed systems.
Paul Soule
2. Distributed Systems Development
Abstract
Computer systems used to be expensive standalone self-contained entities, each with its own disk storage, line printers, terminals and other peripherals. The introduction of the minicomputer made computers cheaper and more widespread, which led to the requirement to share information between them. This requirement led to the development of early computer networks, such as the Unix-to-Unix copy program (UUCP) in 1976 and its subsequent release in AT&T Version 7 Unix in the same year.
Paul Soule
3. An Aspect-Oriented Approach
Abstract
Object-orientation has been presented as the technology that will finally make software reuse a reality as the object model provides a better fit with domain models than procedural programming [63]. Object-orientation, currently the dominant programming paradigm, allows a programmer to build a system by decomposing a problem domain into objects that contain both data and the methods used to manipulate the data, thereby providing both abstraction and encapsulation. In addition, object-oriented languages typically provide an inheritance mechanism that allows an object to reuse the data and methods of its parent, thereby enabling polymorphism.
Paul Soule
4. The Distribution Definition Language
Abstract
In Chapter 2 we discussed distributed systems development and the issues surrounding the use of frameworks and programming conventions and the alternative network obliviousness model. Neither of these approaches is satisfactory as they either violate the principle of separation of concerns or attempt to hide distribution and recovery altogether. In the previous chapter we provided an overview of the aspect-oriented paradigm and introduced our approach, the high-level domainspecific aspect language approach, which provides both separation of concerns and network obliviousness without compromising either.
Paul Soule
5. The RemoteJ Compiler/Generator Implementation
Abstract
In this chapter we describe the implementation of the RemoteJ compiler/generator. We describe the compiler and its features and discuss the implementation of the recovery concern and the JMS, REST and RMI protocol implementations.
Paul Soule
6. Evaluation
Abstract
RemoteJ has been designed as an alternative method of developing distributed applications to both the Java RMI convention, which requires developers to be aware of the distributed nature of their applications, and the RPC convention, which attempts to make remote procedure calls transparent to the developer.
Both of the above approaches result in applications tangled with the crosscutting concern distribution. Previous work, described in Section 3.8, has shown that an aspect-oriented approach can significantly reduce the tangling between application functionality and the distribution concern, thereby making programs easier to write and understand. However, this previous work has assumed a single protocol and has not considered the recovery concern thereby attempting, once again, to mask the difference between local and remote method calls.
We agree with Waldo et al. [118] that any attempt to paper over the differences between local and remote systems is fundamentally wrong, because distributed systems require that the programmer be aware of issues such as latency and partial failures to be able to support basic requirements of robustness and reliability
Paul Soule
7. Conclusions and Future Work
Abstract
Our hypothesis statement declares that the distribution and recovery concerns can be completely and effectively modularised by defining them in a high-level domainspecific aspect language which can be applied to existing applications using a compiler/generator tool. We believe we have proven this hypothesis by the four contributions we have presented in this book.
Paul Soule
Backmatter
Metadaten
Titel
Autonomics Development: A Domain-Specific Aspect Language Approach
verfasst von
Paul Soule
Copyright-Jahr
2010
Verlag
Springer Basel
Electronic ISBN
978-3-0346-0540-3
Print ISBN
978-3-0346-0539-7
DOI
https://doi.org/10.1007/978-3-0346-0540-3