• RRP: £27.99
  • You Save: £3.68 (13%)
FREE Delivery in the UK.
Only 1 left in stock (more on the way).
Dispatched from and sold by Amazon.
Gift-wrap available.
Trade in your item
Get a £0.13
Gift Card.
Have one to sell?
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See this image

UML Components: A Simple Process for Specifying Component-based Software (Component Based Development Series) Paperback – 18 Oct 2000

See all formats and editions Hide other formats and editions
Amazon Price New from Used from
"Please retry"
£20.09 £0.15

Trade In Promotion

Trade In this Item for up to £0.13
Trade in UML Components: A Simple Process for Specifying Component-based Software (Component Based Development Series) for an Amazon Gift Card of up to £0.13, which you can then spend on millions of items across the site. Trade-in values may vary (terms apply). Learn more

Product details

  • Paperback: 208 pages
  • Publisher: Addison Wesley; 1 edition (18 Oct 2000)
  • Language: English
  • ISBN-10: 0201708515
  • ISBN-13: 978-0201708516
  • Product Dimensions: 17.5 x 1.8 x 22.6 cm
  • Average Customer Review: 4.3 out of 5 stars  See all reviews (3 customer reviews)
  • Amazon Bestsellers Rank: 647,852 in Books (See Top 100 in Books)
  • See Complete Table of Contents

More About the Authors

Discover books, learn about writers, and more.

Product Description

From the Author

The book that tells you how to combine EJB and COM+ with UML
We wrote this book to help those of you who want to use UML to describe components built using technologies such as EJB and COM+. A technology-independent specification of a component is very useful in providing a more abstract view. UML, together with OCL, provides a mechanism for putting precision into the abstract specifications.

Other books provide an overview of UML, but this book explains specifically how to use UML to specify components. Most importantly, it also provides a simple step-by-step process for moving from requirements to component specifications.

From the Back Cover

Developers using component technologies such as COM+ and Enterprise JavaBeans need to be able to define and express specifications for their components. They can do so using the Unified Modeling Language (UML), whether or not the components are being implemented internally using object technology. However, they also need a simple process that ensures specifications relate correctly to requirements.

Although originally conceived as a notation for object-oriented modeling, UML has great potential for component-based systems. UML Components applies UML to the world of component architecture, demonstrating how it can be used to specify components, their interactions, and their integration into cohesive systems. This book shows readers which elements of UML apply to server-side component-based development and how to use them most effectively. Following a simple step-by-step process, the authors walk through requirements definition, component identification, component interaction, component specification, and provisioning and assembly. Throughout, the focus is on the specification of the external characteristics of components and their inter-dependencies, rather than on internal implementation. Numerous UML diagrams illustrate component specifications, and a detailed case study demonstrates important concepts and techniques.

System architects, designers, programmers, and testers interested in leveraging the advantages of UML will find this a concise, practical, and insightful guide. The authors address the two great challenges of designing and constructing enterprise-scale component-based software: finding a process that can support the construction of large component systems, and making the best use of the wide range of notations and techniques found in the UML.


Customer Reviews

4.3 out of 5 stars
5 star
4 star
3 star
2 star
1 star
See all 3 customer reviews
Share your thoughts with other customers

Most Helpful Customer Reviews

2 of 2 people found the following review helpful By A Customer on 24 April 2002
Format: Paperback
On first reading over a year ago (March '01) I found it hard going, now on re-reading, it makes a lot more sense and will be re-read in the next project for the development phase.
The only shortcomings are a lack of discussion on packages, patterns, component dependancy matrix, version release managment in global organisations and FINALLY an example CCM (Corba component Model)/ Catalogue for the Designer and how this should be interpreted by the programmer. Why has it not gained more prominence or is it ahead of the 'Curve' sic hype ?
Overall a job well done but needs updating and I think that it will be welcomed by the whole industry.
Kevin O'Hanain - Business Systems Analyst -London & Dublin
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
2 of 2 people found the following review helpful By A Customer on 21 May 2001
Format: Paperback Verified Purchase
The cover of this book says it all "A Simple Process for Specifiying Component-Based Software".
If you found the Catalysis book oververtly complex (go on admit it) then this book should be next on your purchase list.
The only debate would be whether the use of Mgr suffix on interface types and how this applies to EJBs was discussed adequately.
Initially I was tempted to give this book four stars. However, as this book is pitched as being a "simple process" I think it lives up to its title and is an excellent introduction to CBD.
I hope people buy it and read it.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
2 of 2 people found the following review helpful By A Customer on 14 Mar 2001
Format: Paperback
This book represents the first realistic methodology for CBD I've read.
I've read the Catalysis book, which is overly complex for most people. And Paul Allen's book, which takes a higher level view, never getting down to the nitty-gritty detail required.
This book gives a step by step breakdown of how to do analysis and design for CBD targeting EJB and COM+. And does so, for the most part, realistically - given the nature of EJB and COM+.
Recommended above other books on the subject, although a reading of the Catalysis book, which is cited often in this book, would also be useful.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again

Most Helpful Customer Reviews on Amazon.com (beta)

Amazon.com: 10 reviews
18 of 19 people found the following review helpful
Component Architects enjoy this feast! 21 Jan 2001
By Daniel Moth - Published on Amazon.com
Format: Paperback
Chapter 1 provides an excellent intro to defining what a component is. It also effectively establishes the language and terms that are used in the rest of the book.
The next chapter describes a development process including stages, activities within each stage and the inputs/outputs of each stage. The stages are: Requirements, Specification, Provisioning, Assembly, Test and Deployment. The focus of the book is the details of the Specification stage. We are shown what artefacts are created between substages of the specification stage and how to organise them in our UML tool. UML itself - or rather the subset to be used - is also described, along with a bunch of stereotypes together with the meaning of each (chapter 3).
At this stage, if you are thinking that you are interested in how to capture requirements for developing components OR that you would like to know the details of the `Provisioning' stage with detailed descriptions of how to map a design to both EJB and COM, you will be disappointed. The two areas just mentioned are only touched upon in chapter 4 and part of chapter 8. Also, if your UML tool is not flexible to cater for the various stereotypes and the means of organising them, then the material of the book will only satisfy academic interest. Academics will certainly be satisfied anyway, since the delivery of the various concepts is clean, thorough, complete and based on precise definitions firmly established with the reader (the presence of OCL and design by contract principles are no surprise).
The practitioners (mainly software architects) will only benefit if they do have the flexible UML tool and the development & management environment that they operate in is very component focused and appreciates the importance of specifying component interfaces to the nth degree. This development culture leaves the door open for reuse of the components in alternative environments than the one they were originally conceived for. It also contributes to the ability to evolve the component's implementation without ever disturbing the solid interfaces it exposes. If this is the environment you work in (or aspire to be part of), then you will find chapters 5-7 full of `gold' advice backed by a case study; they prescribe techniques for capturing and organising component identification, interaction and specification.
15 of 17 people found the following review helpful
Realistic exercise used to explain how components are used 3 Jan 2002
By Charles Ashbacher - Published on Amazon.com
Format: Paperback
With few exceptions, and this is not one of them, in computing the word simple should only be applied with some form of relative-to qualification. The dream of creating interchangeable parts out of software has been a goal that first appeared on the horizon some time ago, but up to now, it has yet to make a complete appearance. The authors acknowledge that fact in chapter 8 and argue that with the availability and power of the Unified Modeling Language (UML) to standardize the design coupled with standards such as COM+ and Enterprise Java Beans (EJB) for the run-time side, it is about to happen. While these tools will no doubt accelerate the move to component reuse, the process of the increased adoption of components is more complicated than that.
However, in the arena of the specification of components software using the UML, this book has many positive attributes. There is no preamble or introduction to UML, for that you must use another resource.
This was a good decision on the part of the authors. Many people now know UML and there are several good resources available. Furthermore, the explanations are such that one knowledgeable in computing would quite likely be able to discern what is being described without detailed knowledge of UML.
As the authors stress, the set of steps that will turn a software segment into a component is not difficult to understand. The precise specification of what a component expects and what it is expected to do is the major task that needs to be addressed. A secondary, but necessary task is that the details of the implementation are not part of the component specification, for if they were, then it would violate the concept of interchangeable parts. The basic structures of a design by contract are described using the Object Constraint Language (OCL). It is not necessary to know OCL to understand what is being described, a thorough background in Boolean expressions is all that is needed.
The example used throughout the book is that of a hotel room reservation system. It satisfies the three criteria that any such example must adhere to:
1) It is an operation that is routine to most of us, so there is very little need to explain the basic premises and additional realistic extensions can be added without any substantial explanation.
2) There are enough different features that can be encapsulated into a component so that the complete example is complex enough to be an effective learning tool.
3) The interactions among the components are complex enough so that the real problem of using components, namely specifying how they intercommunicate, can be sufficiently developed.
In sports, projects are divided into two parts, the plan and the execution. If only one is done well, it will not work. The same applies to components as well, whether you are defining them or describing how to define them. In this book, the authors also execute their well-conceived plan. The descriptions are complete, understandable and in the proper order. Granted that this is shorter than the typical technical book, but I had no trouble in reading it in two sessions, a morning and an afternoon in the same day. My attention did not waver and there were only a very few times when I stopped and either reread or looked at a previous page for clarification.
You would have to be the programming equivalent of a cave dweller to believe that components will not become a dominant technology in the very near future. With this book, you can face that future with much of the knowledge that will prevent you from being relegated to the recycle bin of history.
11 of 12 people found the following review helpful
Specification Made Plain 28 April 2001
By R. Williams - Published on Amazon.com
Format: Paperback Verified Purchase
This book has a couple things going for it that make in not only outstanding, but truly unique: 1. It attempts to present an aspect of development in a structured way, without offering it up as some kind of miraculous silver bullet, 2. The literature available on methodology tends to run the gamut from the simplistic (XP) to the baroque (Catalysis). This book makes a compelling argument for a simple process of doing component specification before writing code. We've already introduced many of the concepts into our team and it has made our process much more solid and mature. People are finally waking up to the fact that the future has to be component-based, language or process alone will not deliver us from the throw away world of most modern software.
Also, see the book 'Objects, Components and Frameworks in UML: The Catalysis Approach'. It goes well with this, though @ 1200 pages, it is on the baroque side. The influence of Catalysis on the authors (one of them worked on it) is clear.
8 of 10 people found the following review helpful
Pragmatic Approach to Distributed System Architecture 2 Jun 2001
By Steven Hill - Published on Amazon.com
Format: Paperback
All too often, design books (and practictioners for that matter) fall into a trap of treating the design process like the desired outcome is "Art", rather than focusing on solving business problems and working within time and budget constraints. This book attacks this notion and presents a process that extends UML to be an effective tool in building distributed component architectures. The focus is on meaningful deliverables that evolve through analysis and design iterations, and the techniques will effectively break you of waterfall habits.
3 of 3 people found the following review helpful
Packs a punch... 15 April 2003
By A Customer - Published on Amazon.com
Format: Paperback
Flat out ...I liked this book. Frankly this book could be twice this size and still be good. It compresses a TON of information into a small package. I knew that UML was extensible ...but this book really puts that idea into practice.
Only negative would be the organization of it could be a bit better. The book essentially is giving you documentation guidelines but the 'where to document' sometimes gets blurred with the 'how to document'.
Were these reviews helpful? Let us know