CACL is a protection scheme for objects that offers a simple and flexible model of protection and has an efficient, software-only implementation. The model, based on Access Control Lists (ACLs) integrated with the typ...
详细信息
ISBN:
(纸本)0201533723
CACL is a protection scheme for objects that offers a simple and flexible model of protection and has an efficient, software-only implementation. The model, based on Access Control Lists (ACLs) integrated with the type system, allows owners to control who may invoke which methods on which objects, permits cooperation between mutually suspicious principals, allows ownership of objects to be transferred safely, prevents unwanted propagation of authority between principals, and allows changes to the authorization information to take effect on the next method invocation. The implementation, based on the integration of Capabilities with method dispatch, avoids the overhead of access checking in the majority of invocations, at the cost of space for extra dispatch vectors. CACL offers a viable mechanism for fine-grained protection in an object-oriented database system.
This experience paper discusses the use of index card based analysis tools by small teams of prototypers and system end users as a means for investigating potential Human Computer Interaction (HCI) concepts for future...
详细信息
ISBN:
(纸本)0201533723
This experience paper discusses the use of index card based analysis tools by small teams of prototypers and system end users as a means for investigating potential Human Computer Interaction (HCI) concepts for future software development purposes. Several refinements to the basic Class-Responsibilities-Collaborators (CRC) card technique referenced in [Beck & Cunningham] have been made including: the use of a scenario narrative to guide the analytical process;the incorporation of user action and object connection cards;the color coding of cards;and the use of story boards and card model diagrams. Emphasis is placed on the identification of object connection types as a means of suggesting temporal, spatial, comparative and organizational HCI metaphors.
object-orientedsystems Analysis (OSA) meets the needs of both theoreticians and practitioners by providing tunable formalism. In this paper, we show how an OSA user's use of formalism can be tuned from completely...
详细信息
ISBN:
(纸本)0201533723
object-orientedsystems Analysis (OSA) meets the needs of both theoreticians and practitioners by providing tunable formalism. In this paper, we show how an OSA user's use of formalism can be tuned from completely informal to completely formal. We give OSA's underlying formal definition that makes this possible as a two-step process involving a temporal, first-order logic language, and a mathematical interpretation. We also show how the formal definition provides answers to fundamental, practical questions related to object-oriented software development. Finally, we show how OSA allows varying levels of abstraction and completion so that engineers, tool builders, and researchers can tune the formalism to suit their needs.
Traditional document editors are large and complex. Using first-class objects to represent individual characters in a document, we have implemented an editor that is much smaller and simpler than editors of comparable...
详细信息
ISBN:
(纸本)0201533723
Traditional document editors are large and complex. Using first-class objects to represent individual characters in a document, we have implemented an editor that is much smaller and simpler than editors of comparable power. This editor, named `Doc', uses object sharing to reduce memory usage and an incremental update strategy to minimize screen redraw time. Our measurements show the current Doc implementation uses 10 bytes for each character in a document and 30 bytes for each visible character. On a 10-MIPS workstation, Doc can draw over 10 full pages per second and can keep pace with interactive typing speeds. These measurements and our experience using Doc shows that a fully object-oriented approach to document editing is practical. We used the editor to prepare and publish this paper.
The development of large, complex systems consisting of both hardware and software normally involves several companies and/or development teams for the development of the different subsystems forming the entire system...
详细信息
ISBN:
(纸本)0897916107
The development of large, complex systems consisting of both hardware and software normally involves several companies and/or development teams for the development of the different subsystems forming the entire system. Depending on the kind of subsystem to be developed, these different development teams normally use different system engineering methodologies and/or tool sets to produce their subsystems. However, the usage of different methodologies and tools makes technical management and quality assurance for the entire development effort a difficult task. Therefore the development as well as the maintenance of future systems with their increasing size and complexity requires a common frame for the entire system development and maintenance effort covering different kinds of subsystems, like graphical user interfaces, database systems, expert systems, real-time systems, and so on. This common frame should support the separate and independent development of the different subsystems by different subcontractors using different system engineering methods, the integration of these subsystems to the entire system as well as the maintenance of the entire system. A hierarchical object-oriented model for the encapsulation and integration of different system engineering methods can serve as this common frame, providing traceability from the system requirements model to the implemented system while giving each subsystem development team full scope in choosing the system engineering method most suitable for a specific subsystem. The approach underlying this object-oriented model is the encapsulation of the different subsystems in "high-level objects," which can be either further decomposed into "high-level object" or described in more detail using any appropriate system engineering method. The integration of these "high-level objects" to the entire system is supported by a "definition object" on each layer of each system engineering model. The "definition objects" provide trace
The early chapters in the evolving history of object-oriented software development have been dominated by the orthodoxy that objects are real and the job of the systems analyst or software engineer is to abstract them...
详细信息
ISBN:
(纸本)0201533723
The early chapters in the evolving history of object-oriented software development have been dominated by the orthodoxy that objects are real and the job of the systems analyst or software engineer is to abstract them from the so-called `real' world. The composition of object-oriented designs within this orthodoxy is based on the constructs or concepts of the application domain, essentially static abstractions to which dynamic behavior can be attached. A few methodologists have arrived at a more heretical perspective that looks to behavior as the first or principal guide to successful object-oriented analysis and design. These heretics have developed methods that organize behavior and object abstractions around the events or transactional sequences that an application must handle. Although analysis and design methods that focus on events have been prominent in function-oriented software development, from early transaction-centered approaches to event-partitioning in modern essential systems analysis, they are not yet widely known or well understood in the object-oriented world. This panel explores some of the similarities and differences in these event-oriented methods and compares them in principle and in practice with more `conventional' object-oriented approaches. Panelists were asked to address in their position statements the following issues: What are the most essential concepts and techniques in your method? How does your method differ from other object-oriented analysis and design approaches, especially from `mainstream' methods based on `real world' application domain entities? In practice, what are the major consequences or results of using your method or approach, especially in terms of software organization or architecture and long-term economics?
Integrated, dynamically-typed object-orientedprogramming environments offer many advantages, but have trouble producing small, self-contained applications. Recent advances in type inference have made it possible to b...
详细信息
暂无评论