Download UML Components: A Simple Process for Specifying Component-Based Software, by John Cheesman, John Daniels
Find out the strategy of doing something from several resources. One of them is this publication entitle UML Components: A Simple Process For Specifying Component-Based Software, By John Cheesman, John Daniels It is an extremely well understood book UML Components: A Simple Process For Specifying Component-Based Software, By John Cheesman, John Daniels that can be recommendation to read currently. This suggested publication is among the all terrific UML Components: A Simple Process For Specifying Component-Based Software, By John Cheesman, John Daniels collections that are in this site. You will certainly additionally find other title and also themes from various authors to look below.
UML Components: A Simple Process for Specifying Component-Based Software, by John Cheesman, John Daniels
Download UML Components: A Simple Process for Specifying Component-Based Software, by John Cheesman, John Daniels
UML Components: A Simple Process For Specifying Component-Based Software, By John Cheesman, John Daniels. What are you doing when having spare time? Talking or browsing? Why do not you try to review some e-book? Why should be reading? Checking out is one of fun as well as pleasurable task to do in your leisure. By checking out from numerous sources, you can discover brand-new information and experience. The books UML Components: A Simple Process For Specifying Component-Based Software, By John Cheesman, John Daniels to read will certainly be many starting from clinical books to the fiction e-books. It implies that you could review the publications based on the requirement that you intend to take. Of program, it will be different and you could review all publication types any type of time. As below, we will reveal you a publication need to be read. This publication UML Components: A Simple Process For Specifying Component-Based Software, By John Cheesman, John Daniels is the choice.
This book UML Components: A Simple Process For Specifying Component-Based Software, By John Cheesman, John Daniels deals you much better of life that could create the quality of the life better. This UML Components: A Simple Process For Specifying Component-Based Software, By John Cheesman, John Daniels is exactly what the people now require. You are below and you might be precise and sure to get this publication UML Components: A Simple Process For Specifying Component-Based Software, By John Cheesman, John Daniels Never doubt to obtain it also this is merely a publication. You can get this book UML Components: A Simple Process For Specifying Component-Based Software, By John Cheesman, John Daniels as one of your collections. Yet, not the collection to show in your bookshelves. This is a priceless publication to be checking out collection.
How is making certain that this UML Components: A Simple Process For Specifying Component-Based Software, By John Cheesman, John Daniels will not shown in your bookshelves? This is a soft data book UML Components: A Simple Process For Specifying Component-Based Software, By John Cheesman, John Daniels, so you can download UML Components: A Simple Process For Specifying Component-Based Software, By John Cheesman, John Daniels by acquiring to get the soft documents. It will certainly relieve you to review it every time you need. When you really feel careless to move the printed publication from home to office to some place, this soft documents will certainly reduce you not to do that. Because you can only conserve the data in your computer unit as well as gizmo. So, it allows you read it everywhere you have determination to check out UML Components: A Simple Process For Specifying Component-Based Software, By John Cheesman, John Daniels
Well, when else will you discover this prospect to get this book UML Components: A Simple Process For Specifying Component-Based Software, By John Cheesman, John Daniels soft data? This is your great opportunity to be below as well as get this wonderful publication UML Components: A Simple Process For Specifying Component-Based Software, By John Cheesman, John Daniels Never ever leave this book prior to downloading this soft documents of UML Components: A Simple Process For Specifying Component-Based Software, By John Cheesman, John Daniels in web link that we provide. UML Components: A Simple Process For Specifying Component-Based Software, By John Cheesman, John Daniels will actually make a large amount to be your buddy in your lonely. It will be the very best companion to boost your business as well as leisure activity.
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 componen
- Sales Rank: #2046015 in Books
- Published on: 2000-10-28
- Original language: English
- Number of items: 1
- Dimensions: 9.10" h x .40" w x 7.30" l, .70 pounds
- Binding: Paperback
- 208 pages
From the Inside Flap
This book describes how to architect and specify enterprise-scale component-based systems.
It is a practical and technical book. The business benefits of a component-based approach to building systems have been well documented in many theoretical books and we don't repeat these. Our focus is on helping people move from the theory to the detailed reality.
It seems to us that people who want to take a model-based approach to the design and construction of enterprise-scale component-based software face two big problems. First, what tasks and techniques can they use that will both produce a good system and be compatible with whatever project management process is in use? Little has been written to date about processes that can support the construction of large component systems. Second, how should they use the wide range of notations and techniques found in the Unified Modeling Language (UML)? The UML has become the de facto standard for pretty much all application development modeling, but its application to component-based approaches isn't obvious.
If you flick through the pages it might seem to you that we've concentrated mainly on the second of these problems--there are lots of UML diagrams--but a deeper examination will show, we hope, that the primary emphasis is on explaining a simple process by which components can be identified and specified, and robust but flexible application architectures can be produced.
Of course, the full development process covers more than just specification; it covers all activities from requirement gathering to system deployment. But this book focuses on specification. It explains how to represent requirements in a way that will facilitate the construction of specifications, it shows how to create specifications, and it gives guidance on implementing the specifications in software. We make no apology for focusing on specification. The main challenge that a component approach can meet is dealing with change, but the substitutability of parts this requires can be achieved only if components are properly specified.
Underpinning the process are a set of principles and definitions that organize and structure our thinking about software components. We have found these ideas to be a great help, and we urge you to take the time to understand and appreciate them. You'll find them set out in Chapter 1.
Who Should Read This Book? We have written this book for practitioners--people who need to architect systems and specify components in UML today, using today's tools. We describe a clear process for moving from business requirements to system specifications and architectures. This will be helpful for those struggling with business-IT alignment in today's e-business world. The architecture pieces will assist those focusing on system architectures and assemblies, from city planning through detailed application architectures. The emphasis on unambiguous interface specification will be useful for those trying to establish software factories, those defining clear buy-and-build software policies, and those involved in application integration and legacy migration. It should also appeal to testing and validation teams.
We also think this book contains sufficient conceptual clarity and succinct explanations of techniques to make it of interest to both academics and educators. We certainly hope they will buy it.
How Best to Read This Book Start at page 1 and keep going. When you reach a page that's thicker than the rest and shiny on one side, you're done. Seriously though, this isn't a big book, and we think you'll get most from it if you read it all. We think it's all important, so we can't suggest sections to skip on first reading, although you might find it useful the first time through only to skim some of the detailed specification examples, especially in Chapter 7. In fact, we tried to write the kind of book we like to read ourselves--lean and mean, with no unnecessary asides to distract from the main message.
Having read it all once, however sketchily, you will probably want to dip in and out of particular chapters as you're dealing with specific issues on your projects.
If you want to dig deeper into the examples we have provided, you can find the full case study at umlcomponents.
Where Did These Ideas Come From? We'd like to think that the ideas in this book are all our own, but they're not. The component concepts and the process ideas we've used have been formed over a number of years and derive from a great many sources. We've relied heavily on the expertise of others who have struggled with--and solved, at least partially--related problems.
On John Cheesman's side the ideas come from his early work on the Microsoft Repository Open Information Model (OIM), in the mid-1990s; his work with Desmond D'Souza and Alan Cameron Wills on the Catalysis meta-model D'Souza99; UML, of course, to which he was a direct contributor; and Sterling Software's Advisor method for component-based development Advisor, developed mainly by John Dodd and itself influenced by Catalysis.
John Daniels is one of the pioneers of object-oriented concepts and practices. In the early 1990s he developed, together with Steve Cook, the Syntropy method Cook94. This work has been a forerunner and common ancestor of many of the later developments mentioned above, especially Catalysis. The UML's Object Constraint Language (OCL) is directly descended from Syntropy, and several ideas first seen in Syntropy have found their way into the UML.
Figure P.1, although inevitably a simplification, gives some insight into how the ideas have influenced each other. Of course each of these areas has its own set of influences, which we haven't shown, although OMT Rumbaugh91 and Bertrand Meyer's notions of design by contract Meyer00 deserve special mention.
We joined forces in 1999 to refine the concept models, tighten the process ideas, and align them with the workflows and terminology of the Rational Unified Process (RUP) Jacobson99. This book is the result.
Practical Experience We have greatly benefited from studying the experiences of the Sterling Software component-based development (CBD) Customer Advisory Board (CAB). This is a set of companies who have been developing enterprise-scale component-based applications since 1996 in a variety of vertical domains, from telecoms to transportation, and finance to manufacturing. At the time of writing, the CBD CAB has around one hundred member companies.
These companies have helped to separate what works in practice and has genuine, practical added value from what sounds good but is impractical on a real project. They've kept our feet firmly on the ground.
What works in practice is often a function of how well a particular process or technique is supported by application development tools. And it has to be said, most UML tools don't do a great job of supporting component-based development. We avoid references to specific tools in this book since we want it to have a broad appeal, and we try to keep as close to standard UML as we can, defining a relatively small set of extensions. But clearly, the better your tool of choice supports these concepts and processes, the more practical you will find them.
John Cheesman Surrey, England johnc@componentsource
John Daniels London, England john@syntropy.co.uk
0201708515P04062001
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.
0201708515B04062001
About the Author
John Cheesman is Director of Enterprise Application Development for ComponentSource. He has extensive experience applying component-based development processes, tools, and standards within large corporations. John specializes in modeling, specification, and repositories, and was a key contributor to the development of the UML. He is a regular speaker at international conferences on component-based development. John Daniels is an independent consultant and trainer. A pioneer of object-oriented concepts and practices, John has applied object and component technology to a wide range of fields during the past fifteen years, from factory automation to banking. He co-developed the Syntropy method, from which the UML Object Constraint Language is directly descended. John is a frequent speaker at international conferences on object technology, components, and development processes, and is co-author of Designing Object Systems: Object-Oriented Modeling with Syntropy (Prentice-Hall, 1994).
0201708515AB04062001
Most helpful customer reviews
2 of 2 people found the following review helpful.
Clearest description so far
By wiredweird
If you had trouble using the UML to handle component systems, there's a good reason for it. The UML is so broad, has so many parts, and has so exponentially many combinations that fitting it to any one discipline is a job for experts.
Here is the book by the experts. This starts with the basics. First, they say what they mean by a component - valuable, because authors all differ. Then they cover a few of the development basics, including project management and requirements. This really isn't a process book, though, so those topics get just enough discussion for the rest to make sense.
The real meat of the book starts in Ch.3, "Applying UML." That opens the topic that this book is really about, and gives a quick review of the kinds of UML diagrams used. Ch.5-6 look a lot like traditional OO analysis, not surprising because OO is the implementation mechanism for any modern component mechanism. Also, like OO, component systems emphasize bundling of data with operations. In fact, the experienced OO developer should pay more attention to the differences between OO and component analysis than the similarities. Whether your development involves components or not, you'll still find a detailed case study of the UML applied to a realistic sample design. In particular, the many different roles of interfaces apply as well to OO software as to components.
Ch. 7 goes into the real detail, esp. use of the Object Constraint Language (OCL) for interface specification. This is Meyer's "design by contract" specification technique, cast into UML/OCL terms. Although the material is good, I came away with mixed feelings about it.
On one hand, the material involves a very high level of detail, possibly enough to put some readers off. "Design by contract" is a descendant of mathematical proof of program correctness. It's a whole new aspect of programming, with a whole new set of thought processes involved and a whole new set of problems to get lost in. My experience of typical production programmers is that the contracts will probably end up a) vacuously general, or b) a never-ending mesh of inconsistencies, or c) ignored. I like contracts, and I like formal specification of behavior, I just don't see that the average practitioner is ready for it.
On the other hand, I found some maddening omissions. The authors repeatedly warn that aggregation has subtle semantic implications, that collections need special attention, and so on. They don't say what the problems are, though, or give pointers to readings that can be accessed readily.
The authors note that CASE tools of the day are not ready for such broad, intensive use of detailed UML features. Worse, some UML features are mis-supported, and the user may have to fight the tools to get the results desired. That's fair; if anything, I appreciate the honesty. UML as a whole is too big, and its usage is evolving too rapidly for the tools to catch up. The best UML-related writings today, this included, describe usages that ought to work but, in commercial reality, don't.
There is one peculiarity here that I never figured out. The UML is a standard from the Object Management Group (omg.org). So is CORBA, with its component model. Why, then, did the authors address COM+ and EJB components but not CORBA? Maybe the CORBA model isn't mature enough, but I really don't know.
This the best, maybe the only book that pays serious attention to component software in UML terms.
//wiredweird
11 of 12 people found the following review helpful.
Specification Made Plain
By R. Williams
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.
18 of 19 people found the following review helpful.
Component Architects enjoy this feast!
By Daniel Moth
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.
UML Components: A Simple Process for Specifying Component-Based Software, by John Cheesman, John Daniels PDF
UML Components: A Simple Process for Specifying Component-Based Software, by John Cheesman, John Daniels EPub
UML Components: A Simple Process for Specifying Component-Based Software, by John Cheesman, John Daniels Doc
UML Components: A Simple Process for Specifying Component-Based Software, by John Cheesman, John Daniels iBooks
UML Components: A Simple Process for Specifying Component-Based Software, by John Cheesman, John Daniels rtf
UML Components: A Simple Process for Specifying Component-Based Software, by John Cheesman, John Daniels Mobipocket
UML Components: A Simple Process for Specifying Component-Based Software, by John Cheesman, John Daniels Kindle
