Reifying Design Patterns as Metalevel Constructs

A design pattern describes a structure of communicating components that solves a commonly occurring design problem. Designing with patterns offers the possibility of raising the abstraction level at which design is performed, with improvements in clarity, understanding, and facility of maintenance of applications. However, in their most common presentation, design patterns are informal pieces of design process, which application is not reflected in the operational system, and the potential advantages of a more principled design are not realized. This work proposes to organize design in such a way that pattern applications remain explicit in the operational systems. A reflective architecture is proposed, where patterns are reified as metalevel constructs.Sociedad Argentina de Informática e Investigación Operativ

A Tale of Action-Research in Information Systems: Memories of a Ph.D. Student

This paper tells the tale of a Ph.D. student who used action-research to establish an information systems design methodology. It describes how he initiated his project, how he came across action-research, and how he slowly evolved in his search for coherence until he felt he could progress confidently. The paper is mainly intended to offer to readers who are unfamiliar with action-research a context where they can become aware of some of the difficulties of its use how they can be solved, and recognize some criteria that can be met to ensure that the results obtained are scientifically valid. The paper concludes by reflecting on the close relationship between action-research and the epis¬temology of the information systems field, suggesting that this relationship should be the object of further exploration

A Specification Environment That Supports the Prototyping of Distributed Systems Using an Object-Oriented Model.

High-speed computer networking, interactive service, and incremental growth for computing are some of the motivations for developing a distributed system. Despite the inherent benefits of a distributed system, the development of software support is more difficult for distributed systems than for sequential systems. In either case, difficulties may arise from the communication problems between two groups of people with different backgrounds trying to formulate requirements for the system. This process depends on feedback and may take many iterations to converge. Customers can usually recognize the features they need when they start using a system, which makes prototyping an important tool in requirement analysis. Many prototyping goals, objectives, and approaches are possible. Executable formal specifications are the most attractive ones. This unification of specification and prototyping by having code generators has advantages of providing consistency and prototyping at higher levels of abstraction. Thus, a methodology for executing the DOSL (Distributed Object-based Specification Language) is defined and a prototype system is developed. DOSL is extended as a new formal distributed object-oriented specification language, DOSL-II. DOSL-II is object-oriented rather than object-based, and includes class, inheritance, simple I/O, stream I/O, concurrent I/O, and new constructs for object communication

Structuring fault-tolerant object-oriented systems using inheritance and delegation

PhD ThesisMany entities in the real world that a software system has to interact with, e.g., for controlling or monitoring purposes, exhibit different behaviour phases in their lifetime, in particular depending on whether or not they are functioning correctly. That is, these entities exhibit not only a normal behaviour phase but also one or more abnormal behaviour phases associated with the various faults which occur in the environment. These faults are referred to as environmental faults. In the object-oriented software, real-world entities are modeled as objects. In a classbased object-oriented language, such as C++, all objects of a given class must follow the same external behaviour, i.e., they have the same interface and associated implementation. However this requires that each object permanently belong to a particular class, imposing constraints on the mutability of the behaviour for an individual object. This thesis proposes solutions to the problem of finding means whereby objects representing real-world entities which exhibit various behaviour phases can make corresponding changes in their own behaviour in a clear and explicit way, rather than through status-checking code which is normally embedded in the implementation of various methods. Our proposed solution is (i) to define a hierarchy of different subclasses related to an object which corresponds to an external entity, each subclass implementing a different behaviour phase that the external entity can exhibit, and (ii) to arrange that each object forward the execution of its operations to the currently appropriate instance of this hierarchy of subclasses. We thus propose an object-oriented approach for the provision of environmental fault tolerance, which encapsulates the abnormal behaviour of "faulty" entities as objects (instances of the above mentioned subclasses). These abnormal behaviour variants are defined statically, and runtime access to them is implemented through a delegation mechanism which depends on the current phase of behaviour. Thus specific reconfiguration changes at the level of objects can be easily incorporated to a software system for tolerating environmental faults

Rethinking Consistency Management in Real-time Collaborative Editing Systems

Networked computer systems offer much to support collaborative editing of shared documents among users. Increasing concurrent access to shared documents by allowing multiple users to contribute to and/or track changes to these shared documents is the goal of real-time collaborative editing systems (RTCES); yet concurrent access is either limited in existing systems that employ exclusive locking or concurrency control algorithms such as operational transformation (OT) may be employed to enable concurrent access. Unfortunately, such OT based schemes are costly with respect to communication and computation. Further, existing systems are often specialized in their functionality and require users to adopt new, unfamiliar software to enable collaboration. This research discusses our work in improving consistency management in RTCES. We have developed a set of deadlock-free multi-granular dynamic locking algorithms and data structures that maximize concurrent access to shared documents while minimizing communication cost. These algorithms provide a high level of service for concurrent access to the shared document and integrate merge-based or OT-based consistency maintenance policies locally among a subset of the users within a subsection of the document – thus reducing the communication costs in maintaining consistency. Additionally, we have developed client-server and P2P implementations of our hierarchical document management algorithms. Simulations results indicate that our approach achieves significant communication and computation cost savings. We have also developed a hierarchical reduction algorithm that can minimize the space required of RTCES, and this algorithm may be pipelined through our document tree. Further, we have developed an architecture that allows for a heterogeneous set of client editing software to connect with a heterogeneous set of server document repositories via Web services. This architecture supports our algorithms and does not require client or server technologies to be modified – thus it is able to accommodate existing, favored editing and repository tools. Finally, we have developed a prototype benchmark system of our architecture that is responsive to users’ actions and minimizes communication costs

Evolving Software with Extensible Modules

We present the design of the programming language Keris, an extension of Java with explicit support for software evolution. Keris introduces extensible modules as the basic building blocks for software. Modules are composed hierarchically revealing explicitly the architecture of systems. A distinct feature of the module design is that modules do not get linked manually. Instead, the wiring of modules gets infered. The module assembly and refinement mechanism of Keris is not restricted to the unanticipated extensibility of atomic modules. It also allows to extend fully linked systems by replacing selected submodules with compatible versions without needing to re-link the full system. Extensibility is type-safe and non-invasive; i.e. the extension of a module preserves the original version and does not require access to source code