These are the highlights of a successfully completed application of object-oriented software development for a new product. The project was of medium size, the duration was less than 24 months (from the end of the req...
详细信息
ISBN:
(纸本)0201533723
These are the highlights of a successfully completed application of object-oriented software development for a new product. The project was of medium size, the duration was less than 24 months (from the end of the requirements specification to product shipment), and the average team size was 8-10 software engineers. We discuss how the team dealt with major new aspects: a different paradigm, a different programming language, a different user interface environment, and a different development environment. In spite of all these novelties and in spite of the fact that almost twice as much code was produced as was predicted, the project schedule slipped only by 20%. We touch upon all phases of the development life cycle: requirement capture, OO analysis, OO design, OO implementation and the verification phase. Some management perspectives are addressed as well.
Generational garbage collectors are able to achieve very small pause times by concentrating on the youngest (most recently allocated) objects when collecting, since objects have been observed to die young in many syst...
详细信息
ISBN:
(纸本)0201533723
Generational garbage collectors are able to achieve very small pause times by concentrating on the youngest (most recently allocated) objects when collecting, since objects have been observed to die young in many systems. Generational collectors must keep track of all pointers from older to younger generations, by `monitoring' all stores into the heap. This write barrier has been implemented in a number of ways, varying essentially in the granularity of the information observed and stored. Here we examine a range of write barrier implementations and evaluate their relative performance within a generation scavenging garbage collector for Smalltalk.
Widespread acceptance of concurrent object-orientedprogramming in the field can only be expected if smooth integration with sequential programming is achieved. This means that a common language base has to be used, w...
详细信息
ISBN:
(纸本)0201533723
Widespread acceptance of concurrent object-orientedprogramming in the field can only be expected if smooth integration with sequential programming is achieved. This means that a common language base has to be used, where the concurrent syntax differs as little as possible from the sequential one but is associated with a `natural' concurrent semantics that makes library support for concurrency superfluous. In addition, not only should sequential classes be reusable in a concurrent context, but concurrent classes should also be reusable in a sequential context. It is suggested that concurrency annotations be inserted into otherwise sequential code. They are ignored by a sequential compiler, but a compiler for the extended concurrent language will recognize them and generate the appropriate concurrent code. The concurrent version of the language supports active and concurrent objects and favours a declarative approach to synchronization and locking which solves typical concurrency problems in an easier and more readable way than previous approaches. Concurrency annotations are introduced using Eiffel as the sequential base.
The hierarchy of interfaces implicit in the Smalltalk-80 collection class library is computed and analyzed. The interface hierarchy is independent of the inheritance hierarchy because methods are frequently deleted by...
详细信息
ISBN:
(纸本)0201533723
The hierarchy of interfaces implicit in the Smalltalk-80 collection class library is computed and analyzed. The interface hierarchy is independent of the inheritance hierarchy because methods are frequently deleted by subclasses, and because unrelated classes sometimes implement the same messages. Specifications of the interfaces are developed, revealing subtle relationships among messages and their methods. The specifications help identify several kinds of problems in the library: inherited methods that violate the subclass invariant;methods that have the same name but unrelated behaviors;methods that have the same (or related) behavior but different names. This exercise demonstrates the utility of interfaces and specifications, and suggests improvements to the collection class library structure.
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?
暂无评论