No label defined (Q4023995)
From MaRDI portal
!
This is the item page for this Wikibase entity, intended for internal use and editing purposes. Please use the normal view instead:
scientific article; zbMATH DE number 108536
| Language | Label | Description | Also known as |
|---|---|---|---|
| default for all languages | No label defined |
||
| English | No label defined |
scientific article; zbMATH DE number 108536 |
Statements
23 January 1993
0 references
object-oriented software development
0 references
use cases
0 references
object-oriented programming
0 references
scenario based analysis
0 references
This book describes an object-oriented software development method which has been developed and applied in several projects by the authors. Its main concepts are: -- specification on the basis of use cases (i.e., scenarios of how a system is being used) -- conceptual system modeling using an object-oriented paradigm -- design with building blocks which are at least partially prefabricated -- object-oriented programming. The book is divided in three parts. The first part gives a short introduction to system development in general, concepts of object- orientation, object-oriented system development, and object-oriented programming. Part two describes the method developed by the authors with chapters on architecture, analysis, construction, real-time specialization, database specialization, components, and testing. Part three,titled applications, presents two case studies, describes management of object-oriented development, and surveys other object-oriented analysis and design methods. The basic ideas of the authors are sound, especially -- the focus on locality and encapsulation -- modularizing the software into reusable building blocks -- the concept of describing required system behaviour with use cases. All these ideas are not new ones. The authors have tied them together and have strengthened the concept of scenario based analysis. In this light, the book makes two main contributions: (1) introducing use cases as a key element in analysis and specification, and (2) putting several proven approaches together to form a software development process. In general, the presented material is easy to read. However, there are some major problems concerning presentation: \(\bullet\) The authors apply a spiral approach to presentation of material: they introduce a topic in some paragraphs, treat it later in a section, and elaborate on it even later in a chapter. This style introduces much redundancy and results in too many forward references (``We will discuss\dots later'', ``We will soon come back to\dots'', ``We shall soon return to\dots''), mostly without saying where. \(\bullet\) Sometimes, the presentation is not very clear. For example, I doubt whether unexperienced readers will understand the implications of information hiding for the design process when reading the last paragraph of section 8.3.1 (p. 233). \(\bullet\) Some key terms (for example, architecture and process) are defined and used in an uncommon way. \(\bullet\) The first edition of the book contained a horrible number of errors and typos (flawed examples, inconsistent notations, wrong figure captions, mismatches between figures and text, grammatical errors, \dots). One is tempted to say that the authors have used the readers as an alpha test site. I have never seen before anything like that. Meanwhile, a revised edition is in the bookstores. Most of the errors have been corrected in this revision. As already mentioned, the principal ideas of the books are good. In my opinion, however, it has also major weaknesses. Below, I discuss one key chapter in detail. Then, I will raise some important issues from the rest of the book. Weak points and mistakes in chapter 3 (``What is object- orientation''): \(\bullet\) The definition of objects on p. 44 omits the key property of unique identifiability. (All page numbers refer to the revised fourth printing of 1993. Page numbering in the first three printings is different.) \(\bullet\) The terms composition, aggregation, and partition are nowhere clearly defined. \(\bullet\) Figure 3.6 shall show the inside of an object. However, it shows neither an object-id nor attribute values, but gives type information (attribute and operation names) instead. \(\bullet\) ``The objects comprising a certain class have\dots'' (p. 50) is wrong. Classes comprise objects, not vice versa. \(\bullet\) The definition of polymorphism (p. 55) is awful. The first clause of the definition describes the effects of polymorphism instead of defining it. The second clause, ``The receiving instance can belong to an arbitrary class'' is simply wrong. The receiving instance must belong to a class having a (locally defined or inherited) method that responds to the stimulus. The correct definition of polymorphism is buried one page later in the text. \(\bullet\) An abstract class has not ``usually'' no instances (p. 59). As far as I know, it has none by definition. \(\bullet\) It is not true, that ``subtyping normally occurs if the inheritance performs only an extension'' (p. 64). An extension frequently will strengthen preconditions or weaken postconditions which is incompatible with subtyping. For example, class Polygon is easily defined as an extension of class Rectangle, but it is definitely no subtype. \(\bullet\) Object-orientation is not simply'' a technique for developing models'' (p. 68). It is a clearly definable set of concepts how to represent models and how to construct them. Other important issues: \(\bullet\) The authors claim that a use case model can ``define the complete functionality of the system'' (p. 159). While this is true in theory, it becomes quickly infeasible in practice, because any state dependent behaviour must be modeled with histories of system usage. However, in their examples, the authors do not model histories, but refer to system state instead. Hence, their use case model is no specification of the complete functionality. \(\bullet\) The description and structuring of use cases is too informal and ad hoc. Use case descriptions in the requirements model and the analysis model have all drawbacks of natural language specifications (high probability of ambiguity, incompleteness, contradictions\dots). Things improve when interaction diagrams are introduced in the design model. When compared to programming languages, the structuring features offered for use cases are on the level of assembly languages. Both abstract use cases (p. 170) and extensions (p. 212, 226ff) are some mixture of macro, subroutine activation, and exception handling concepts. \(\bullet\) The benefit of building two models in the analysis process and maintaining both of them during development is questionable with respect to costs, especially when the authors assume that there is ``an existing requirement (sic!) specification in some form'' prior to analysis (p. 76, also 110). \(\bullet\) Chapter 10 on database specialization was a catastrophe in the first printing. Tables 10.1 and 10.2 could have readily be used in a database course to show how not to design a relational database. In the revised printing, the worst errors have been corrected. However, the authors still do not know the concept of foreign keys, which is fundamental when object-oriented applications store persistent data in a relational database. Furthermore, they still give bad advice for converting object structures into relations. \(\bullet\) The authors employ constructions with unclear and undefined semantics, for example the inheritance of structures in Figure 10.4. \(\bullet\) The graphical notation is vague and nowhere precisely defined. Undefined symbols are being used. The appendix ``Architecture summary'' in the first printing which at least informally summarized the notation, has gone in the revised printing. \(\bullet\) There are some slight contradictions in the text, too. On p. 198, distribution of work according to group structure is a possible means of system structuring (which is a bad idea). Thirteen pages later, the authors advise: ``People and organization\dots should not affect the system structure''. \(\bullet\) In the index, there are missing entries. For example, ``Use cases with extensions'' is a section header on p. 226. However, there is no reference to this page from keyword ``use case'', but only one from keyword ``extends''. To sum up, this is a book containing a lot of good and useful material. However, it also has so many severe weaknesses, that it must be used with care, I can recommend it as a source of inspiration, but not as a standalone textbook on object-oriented software engineering.
0 references