12 research outputs found
Object migration in non-monolithic distributed applications
Object migration is usually applied to optimize distributed
monolithic systems. In this paper, the authors investigate whether
object migration can also be utilized in cooperative systems which
consist of autonomous components.
We show that object migration policies will not always optimize
system performance. Rather they can reduce it drastically if
different components apply these policies concurrently.
Conventional run-time support for linguistic primitives which are
usually used to express migration policies is adapted to cooperative
systems. We show that two novel approaches, place-policy and
reduction of attachment-transitiveness, can counter the degradation
caused by conflicting policies. In order to restrict
attachment-transitiveness we introduce dynamic relationships called
\emph{alliances} between objects which explicitly define cooperation
contexts.
The effects of these modifications are evaluated by simulation
Assessing architectural evolution: A case study
This is the post-print version of the Article. The official published can be accessed from the link below - Copyright @ 2011 SpringerThis paper proposes to use a historical perspective on generic laws, principles,
and guidelines, like Lehman’s software evolution laws and Martin’s design principles, in order to achieve a multi-faceted process and structural assessment of a system’s architectural evolution. We present a simple structural model with associated historical metrics and
visualizations that could form part of an architect’s dashboard. We perform such an assessment for the Eclipse SDK, as a case study of a large, complex, and long-lived system for which sustained effective architectural evolution is paramount. The twofold aim of checking generic principles on a well-know system is, on the one hand,
to see whether there are certain lessons that could be learned for best practice of architectural evolution, and on the other hand to get more insights about the applicability of such principles. We find that while the Eclipse SDK does follow several of the laws and principles, there are some deviations, and we discuss areas of architectural improvement and limitations of the assessment approach
Towards Transitory Encapsulation
Encapsulation and information hiding are essential and fundamental to object-oriented and aspect-oriented programming languages. These principles ensure that one part of a program does not depend on assumptions on the internal structure and logic of other parts of the program. While this assumption allows for clearly defined modules, interfaces and interaction protocols when software is initially developed, it is possible that rigid encapsulation causes problems, such as brittleness, as software changes and evolves over time. We suggest that, just as the strength of type systems have relaxed over time, perhaps structural boundaries could, too be relaxed. Perhaps there could be a new kind of flexible encapsulation: one that allows non-permanent and flexible boundaries between program part