This document describes the results of the two-day Workshop on Aspects and Dimensions of Concern at ecoop 2000. The workshop produced the beginnings of a set of goals, requirements, and issues to be addressed by appro...
详细信息
While object diagrams (ODs) are widely used as a means to document object-oriented systems, they are expressively weak, as they are limited to describe specific possible snapshots of the system at hand. In this paper ...
详细信息
ISBN:
(纸本)9783642226557;9783642226540
While object diagrams (ODs) are widely used as a means to document object-oriented systems, they are expressively weak, as they are limited to describe specific possible snapshots of the system at hand. In this paper we introduce modal object diagrams (MODs), which extend the classical OD language with positive/negative and example/invariant modalities. The extended language allows the designer to specify not only positive example models but also negative examples, ones that the system should not allow, positive invariants, ones that all system's snapshots should include, and negative invariants, ones that no system snapshot is allowed to include. Moreover, as a primary application of the extended language we provide a formal verification technique that decides whether a given class diagram satisfies (i.e., models) a multi-modal object diagrams specification. In case of a negative answer, the technique outputs relevant counterexample object models, as applicable. The verification is based on a reduction to Alloy. The ideas are implemented in a prototype Eclipse plug-in. Examples show the usefulness of the extended language in specifying structural requirements of object-oriented systems in an intuitive yet expressive way.
This book contains the final reports of the workshops held during the 22nd european conference on object-oriented programming, ecoop 2008, in Paphos, Cyprus, in July 2008. The 11 collected reports from high-quality wo...
详细信息
ISBN:
(数字)9783642020476
ISBN:
(纸本)9783642020469
This book contains the final reports of the workshops held during the 22nd european conference on object-oriented programming, ecoop 2008, in Paphos, Cyprus, in July 2008. The 11 collected reports from high-quality workshops - provided by the respective organizers - all are related to selected aspects in the field of object-orientedprogramming and technology. The topics covered span areas related to object-orientedprogramming and technology, such as programming languages, aspects, parallel computing, formal techniques, software engineering, tools, and applications.
Back-in-time debuggers are extremely useful tools for identifying the causes of bugs. Unfortunately the "omniscient" approaches that try to remember all previous states are impractical because they consume t...
详细信息
ISBN:
(纸本)9783540705918
Back-in-time debuggers are extremely useful tools for identifying the causes of bugs. Unfortunately the "omniscient" approaches that try to remember all previous states are impractical because they consume too much space or they are far too slow. Several approaches rely on heuristics to limit these penalties, but they ultimately end up throwing out too much relevant information. In this paper we propose a practical approach that attempts to keep track of only the relevant data. In contrast to other approaches, we keep object history information together with the regular objects in the application memory. Although seemingly counter-intuitive, this approach has the effect that data not reachable from current application objects (and hence, no longer relevant) is garbage collected. We describe the technical details of our approach, and we present benchmarks that demonstrate that memory consumption stays within practical bounds. Furthermore, the performance penalty is significantly less than with other approaches.
The three problems of the title - the first two widely discussed in the literature, the third less well known but just as important for further development of object technology - are: center dot Eradicating the risk o...
详细信息
ISBN:
(纸本)354027992X
The three problems of the title - the first two widely discussed in the literature, the third less well known but just as important for further development of object technology - are: center dot Eradicating the risk of void calls: X. f with, at run time, the target X not denoting any object, leading to an exception and usually a crash. center dot Eradicating the risk of "catcalls": erroneous run-time situations, almost inevitably leading to crashes, resulting from the use of covariant argument typing. center dot Providing a simple way, in concurrent object-orientedprogramming, to lock an object handled by a remote processor or thread of control, or to access it without locking it, as needed by the context and in a safe way. A language mechanism provides a combined solution to all three issues. This mechanism also allows new solutions to two known problems: how to check that a certain object has a certain type, and then use it accordingly ("Run-Time Type Identification" or "downcasting"), for which it may provide a small improvement over previously proposed techniques;and how to provide a "once per object" facility, permitting just-in-time evaluation of certain object properties. The solution relies on a small extension to the type system involving a single symbol, the question mark. The idea is to declare certain types as "attached" (not permitting void values), enforce some new validity rules that rule out void calls, and validate a number of common programming schemes as "Certified Attachment Patterns" guaranteed to rule out void calls. (In addition, the design replaced an existing type-querying construct by a simpler one.) The mechanism is completely static: A checks can be performed by compilers as part of normal type system enforcement. It places no undue burden on these compilers - in particular, does not require dataflow analysis - and can be fairly quickly explained to programmers. Existing code, if reasonably well-written, will usually continue to work wit
Static and dynamic type systems have well-known strengths and weaknesses. In previous work we developed a gradual type system for a functional calculus named lambda(?)(->). Gradual typing provides the benefits of b...
详细信息
ISBN:
(纸本)9783540735885
Static and dynamic type systems have well-known strengths and weaknesses. In previous work we developed a gradual type system for a functional calculus named lambda(?)(->). Gradual typing provides the benefits of both static and dynamic checking in a single language by allowing the programmer to control whether a portion of the program is type checked at compile-time or run-time by adding or removing type annotations on variables. Several object-oriented scripting languages are preparing to add static checking. To support that work this paper develops Obi(<:)(?), a gradual type system for object-based languages, extending the Obi(<:) calculus of Abadi and Cardelli. Our primary contribution is to show that gradual typing and subtyping are orthogonal and can be combined in a principled fashion. We also develop a small-step semantics, provide a machine-checked proof of type safety, and improve the space efficiency of higher-order casts.
Polymorphic inline caches (PICs) provide a new way to reduce the overhead of polymorphic message sends by extending inline caches to include more than one cached lookup result per call site. For a set of typical objec...
详细信息
The objective of this workshop was to discuss current tools and environments for learning object-oriented concepts and to share ideas and experiences about the usage of computer support to teach the basic concepts of ...
详细信息
Concurrency and failures are fundamental problems in distributed computing. One likes to think that the mechanisms needed to address these problems can be separated from the rest of the distributed application: in mod...
详细信息
ISBN:
(纸本)3540437592
Concurrency and failures are fundamental problems in distributed computing. One likes to think that the mechanisms needed to address these problems can be separated from the rest of the distributed application: in modern words, these mechanisms could be aspectized. Does this however make sense? This paper relates an experience that conveys our initial and indeed biased intuition that the answer is in general no. Except for simple academic examples, it is hard and even potentially dangerous to separate concurrency control and failure management from the actual application. We point out the very facts that (1) an aspect-oriented language can, pretty much like a macro language, be beneficial for code factorization (but should be reserved to experienced programmers), and (2) concurrency and failures are particularly hard to aspectize because they are usually par. of the phenomenon that objects should simulate. They are in this sense different than other concerns, like for instance tracing, which might be easier to aspectize.
暂无评论