Skip to main content

Naftaly Minsky

Followers

3

Following

10

Co-author

1

Public Views

I am a theoretical physicit and a computer scientist

less

Interests

Uploads

Papers by Naftaly Minsky

On conditions for self-healing in distributed software systems

This paper attempts to identify one of the necessary conditions for self-healing, or self-repair,... more This paper attempts to identify one of the necessary conditions for self-healing, or self-repair, in complex systems, and to propose means for satisfying this condition in heterogeneous distributed software. The condition identified here is the following: For a system with a wide and open range of possible configurations to be self healing, it must possess suitable regularities, which can be relied upon to be satisfied by all possible configurations of the system, and which must be invariant of its failures. We observe that self healing in physical artifacts, as well as in biological systems, are largely based on regularities engendered by the laws of nature. But since laws of nature have no effective sway over the behavior of software, we propose means for imposing artificial laws over a given distributed system, which are designed to induce desired regularities in them. We demonstrate the efficacy of the proposed approach by applying it to a simple example of electronic purchasing in enterprise systems.

On Shouting “Fire!”: Regulating Decoupled Communication in Distributed Systems

Lecture Notes in Computer Science, 2003

Decoupled communication, which requires no direct association between the producers of informatio... more Decoupled communication, which requires no direct association between the producers of information and its consumers-as under the publish/subscribe (P/S) middleware-is often useful for the integration of distributed and heterogeneous applications. But the indefinite, and potentially global, reach of decoupled communication-the very reason for its power-has a dark side, which may complicate the system using it, making it less predictable, more brittle, and less safe. Just think about the effect of shouting "fire" in a packed theatre, particularly, but not only, if it is a false alarm. It is our thesis that the inherent drawbacks of decoupled communication can be alleviated by decentralized regulation of its use. We show how such regulation can be carried out scalably by means of a distributed control mechanism called Law-Governed Interaction (LGI), and a middleware called Moses that implements this mechanism. And we illustrate the importance of such regulation, and its effectiveness, by considering the treatment of alarms in a large hospital.

Ensuring integrity by adding obligations to privileges

International Conference on Software Engineering, Aug 1, 1985

Conventional authorization mechanisms provide actors with permissions to act, without the actor e... more Conventional authorization mechanisms provide actors with permissions to act, without the actor ever incurring any obligations as a result of executing the permitted action. There exist, however, many situations where system integrity requires that certain actions always be followed by others, within some reasonable time frame. We propose an extension to conventional authorization which allows the explicit association of obligations with permissions, and enforces them. We demonstrate that the extended mechanism can be used to support and enforce several general types of control policies and integrity constraints which are otherwise difficult or impossible to support.

Unshareable dynamic objects and how to resolve a conflict between encapsulation and pointers

This paper introduces the concept of an unshareable dynamic object, i.e., an object that is creat... more This paper introduces the concept of an unshareable dynamic object, i.e., an object that is created dynamically on the heap, and is guaranteed to have a unique and movable pointer leading to it. The use of such unshareable objects, whenever sharing is not required, is expected to fortify the concept of encapsulation, to make systems simpler and easier to reason about, and to make storage management safer and more efficient. We argue that unshareable objects can be implemented by means of few minor and virtually costless modifications in conventional OO languages, and we demonstrate this in detail

Establishing Regularities in Object-Oriented (Eiffel) Systems

Regularities, or the conformity to unifying principles, are essential to the comprehensibility, m... more Regularities, or the conformity to unifying principles, are essential to the comprehensibility, manageability and reliability of large software systems, and should, therefore, be considered an important element of their architecture. But the inherent globality of regularities makes them very hard to implement in traditional methods. We have argued elsewhere that this di culty can be alleviated by means of law-governed architecture (LGA), under which a system designers can establish a desired regularity (of a certain kind) simply by declaring it formally and explicitly as the law of the system. Once such a law-governed regularity is declared, it is enforced by the environment in which the system is developed. This paper, which is based on a recently developed environment called Darwin-E, describes the application of LGA to object oriented systems written in the Ei el language. We introduce here the formalism for specifying laws under Darwin-E, and give a sample of regularities that c...

A problem with long-term computing processes, and what can be done about it

We make here the observation that due to the evolutionary nature of large systems, a long-term pr... more We make here the observation that due to the evolutionary nature of large systems, a long-term process that runs for month or years is generally not driven by any single program, but rather by an unpredictable sequence of programs, (P (1); :::; P (k)), resulting in a serious loss of predictability of the process itself. The main point of this paper is that under LGA such a sequence of programs can be made into a \single organism," with certain invariant properties established by the law of the software development project. To demonstrate the feasibility and usefulness of such evolutionary invariants under LGA, we discuss in this paper the design of a law-governed evolving nancial system in which certain important policies of "internal control" (such as separation of duties between the base system and its auditors) are established as invariants by formulating them as the law of the system.

What should we do about the evolution of software

ACM SIGSOFT Software Engineering Notes, 1986

On interaction with data bases

Proceedings of the 1976 ACM SIGFIDET (now SIGMOD) workshop on Data description, access and control - FIDET '76, 1976

The main thesis of this paper is that interaction with data bases is fundamentally different from... more The main thesis of this paper is that interaction with data bases is fundamentally different from file manipulation: In the former case the data base should be "the master," while the file is a passive collection of data. The main corollaries of this observaction are: a) The conventional update and retrieval operations, traditionally used for files, are not satisfactory as the primitives of users data-base interaction. b) The privacy and integrity of the data base cannot be secured by "access control" alone; there must be a way for the data base to control the user's program itself.

Rotating storage devices as partially associative memories

Proceedings of the December 5-7, 1972, fall joint computer conference, part I on - AFIPS '72 (Fall, part I), 1972

Providing multiple views for objects by means of surrogates

Joint proceedings of the second international software architecture workshop (ISAW-2) and international workshop on multiple perspectives in software development (Viewpoints '96) on SIGSOFT '96 workshops, 1996

One often needs to adapt an single object to several different types of usage in different parts ... more One often needs to adapt an single object to several different types of usage in different parts of a single system-all at the same time. We refer to such adaptations as views of the object. Such views may differ from the base object in question, and from each other, in two ways: (a) they may allow different access to the intrinsic features of the base object, and (b) they may associ\ate with the base object some additional, eztrinsic features which may be meaningful only with respect to a given view . Consider, for example, an evolving medical information systein M. Suppose that this system is partitioned into several disjoint divisions, which are to be developed more or less independently of each other.

Files with semantics

Proceedings of the 1976 ACM SIGMOD international conference on Management of data - SIGMOD '76, 1976

Regulated coordination in open distributed systems

Lecture Notes in Computer Science, 1997

Modern distributed systems tend to be conglomerates of heterogeneous subsystems, which have been ... more Modern distributed systems tend to be conglomerates of heterogeneous subsystems, which have been designed separately, by different people, with little, if any, knowledge of each other. A single agent operating within a hybrid system of this kind may have to coordinate its activities with members of several such subsystems, under different coordination policies. To support coordination in such hybrid systems, we introduce in this paper a new concept of regulated coordination that allows a single agent to engage in several different .activities, subject to disparate policies. Coordination policies are enforced to ensure compliance with them by all participants. We introduce a toolkit called Moses that can support a wide range of useful coordination policies of this kind, in an efficient and unified manner.

Locality in software systems

Proceedings of the 10th ACM SIGACT-SIGPLAN symposium on Principles of programming languages - POPL '83, 1983

This paperl proposes a technique for what we call 'Th6 work has been part!ally supported by NSF g... more This paperl proposes a technique for what we call 'Th6 work has been part!ally supported by NSF grant MCS-8009811. Permission to copy without fee all or part of this material is granted provided that the copies are not made or distributed for direct commercial advantage, the ACM copyright notice and the title of the publication and hsdateappear,and notice is given that copying is by permission of the Association for Computing Machinery. To copy otherwise, or to republish, requiresa feeand/or specific permission.

Should architectural principles be enforced?

Proceedings Computer Security, Dependability, and Assurance: From Needs to Solutions (Cat. No.98EX358)

The construction of complex, evolving software systems requires a high-level design model. Howeve... more The construction of complex, evolving software systems requires a high-level design model. However, this model tends not to be enforced on the system, leaving room for the implementors to diverge from it, thus differentiating the designed system from the actual implemented one. The essence of the problem of enforcing such models lies in their globality. The principles and guidelines conveyed by these models cannot be localized in a single module, they must be observed everywhere in the system. A mechanism for enforcement needs to have a global view of the system and to report breaches in the model at the time they occur. Aspect-Oriented Programming has been proposed as a new software engineering approach. Unlike contemporary software engineering methods, which are module centered, Aspect Oriented Programming provides mechanisms for the definition of cross-module interactions. We explore the possibility of using Aspect-Oriented Programming in general and the AspectJ programming language in particular for the enforcement of design models.

Configuration management by consensus: an application of law-governed systems

ACM SIGSOFT Software Engineering Notes, 1990

It is self-evident that if one wants to model and control the cooperative process of software dev... more It is self-evident that if one wants to model and control the cooperative process of software development, one must provide for cooperative decision making. In particular, one should be able to base the decision on whether and how to carry out a given operation on the consensus of several, possibly independent, agents. It is important to emphasize that this is not just a matter of computing the conjunction of some set of conditions. One must also provide a mechanism for establishing any desired consensus structure, which would specify who is allowed to state which kinds of concerns regarding this operation, and what the relationship among these concerns should be. In this paper we propose a general framework for such decision making by consensus, which is based on the concept of law-governed software development. As a concrete application domain in which to illustrate this framework, we consider here the issue of configuration binding.

System = program + users + law

Proceedings of the first international conference on Artificial intelligence and law - ICAIL '87, 1987

Thii paper is based on a new approach for dealing with large scale software systems. This approac... more Thii paper is based on a new approach for dealing with large scale software systems. This approach is based on the concept of a Law-Governed Sys2em, which is a triple <program, us$rs, law> where the law is an czplicit and strictly enforced set of rules about the structure and operation of the program, and about the evolution of the entire system. We describe Darwin, a skeleton of a programming environment that supports our notion of law-governed systems. Darwin is based. on the object-oriented programming paradigm and uses logic programming to express and enforce the law. 'The term "evolution" is underntood here to include the development and the maintenance of a syrtem.

A law-based approach to object-oriented programming

ACM SIGPLAN Notices, 1987

The central idea behind this paper is that the discipline governing the exchange of messages betw... more The central idea behind this paper is that the discipline governing the exchange of messages between objects should be specifiable by the programmer in the form of an explicit law of the system . We show how, starting from a very primitive foundation, which presumes neither encapsulation nor inheritance, one can establish various forms of both, as well as other useful disciplines, simply by means of appropriate laws.

The Darwin software-evolution environment

ACM SIGPLAN Notices, 1984

The main goal of the Darwin software development environment is to establish a rigorous authoriza... more The main goal of the Darwin software development environment is to establish a rigorous authorization-based discipline which can be used to impose constraints on the structure and operations of software systems as well as on their process of development Such constraints might be desirable to serve the following needs: • The need to provide support and enforcement for such software engineering techniques as informationhiding, data abstraction and modularization, even when these techniques are not offered by the programming language itself. •The need to support rules which govern the real enterprise being served by the system, and which must be invariant of the evolutionary behaviou of the system. • The need to enforce managerial policies concerning the process of system development itself.

A software development environment for law-governed systems

ACM SIGSOFT Software Engineering Notes, 1988

This paper describes a software development environment based on a new approach for managing larg... more This paper describes a software development environment based on a new approach for managing large-scale evolving systems. Under this approach, the conventional notion of a system is augmented with a new component called the law of the system , which is an explicit and strictly enforced set of rules about the operation of the system, about its evolution, and about the evolution of the law itself. The resulting combination is called a law-governed system.

Towards architectural invariants of evolving systems

ACM SIGSOFT Software Engineering Notes, 2000