- Paperback: 274 pages
- Publisher: Pearson Education; 1 edition (2004)
- Language: English
- ISBN-10: 8177586750
- ISBN-13: 978-8177586756
- Product Dimensions: 22 x 17 x 1.5 cm
- Average Customer Review: 3 customer reviews
Amazon Bestsellers Rank:
#74,437 in Books (See Top 100 in Books)
- #1192 in Computer Science Textbooks
UML for Java Programmers, 1e Paperback – 2004
Save Extra with 3 offers
- Cashback (3): Flat Rs.50 back using Amazon Pay UPI. For Android App customers only. Valid once during offer period. Cashback within 10 days. Set up Amazon Pay UPI Here's how
- Get 10% cashback using RuPay cards. Max Cashback - INR 100 if you are using RuPay card for first time on Amazon. INR 25 if you have used RuPay card earlier. Check here for your cashback eligibility Here's how
- Get GST invoice and save up to 28% on business purchases. Sign up for free Here's how
- No Cost EMI: No cost EMI available on Amazon Pay ICICI credit card on orders above Rs.3000 Here's how
- Bank Offer: Get 1500 Instant Discount on ICICI bank Credit and Debit EMI transactions Here's how
Customers who bought this item also bought
Customers who viewed this item also viewed
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter mobile phone number.
Showing 1-3 of 3 reviews
There was a problem filtering reviews right now. Please try again later.
Most helpful customer reviews on Amazon.com
It only covers 5 of the 11 or so UML diagram types, but it covers the ones that will really be used by java programmers day-to-day, in design documents, whiteboards, etc. For each it talks about real world, practical approaches on how to use them to communicate ideas.
Bob Martin is an 'Agile' guy, and it really comes across in this book. A lot of his arguments come down to "A lot of the pomp and circumstance surrounding UML is pretty useless, except when it isn't", and while he tries to instill when that will be, that kind of knowledge reaslly only comes with experience. He also advocates that the diagrams should be 'lightweight enough to be thrown away', which is an opinion that can rub a lot of people the wrong way, is a very valid position. While there is nothing inherently 'good' or 'evil' about UML, it is often used to help create a 'documentation glut'. I have seen situations where the documentation falls out of sync with the code, or worse... the code can't change because the documentation cannot be updated (because of some beurocratic red tape). The author seems to have had some bad experiences along these lines, and seems to have a lot of reactionary thoughts.
This is good! while a couple of other reviews here have called such advice 'impractical' (which it can be in a lot of environments), the information in the book is very valuable and the thought provoking nature about 'be as lightweight as you can' and 'avoid the UML police' are useful as long as you can take them with a grain of salt and apply the advice judiciously in your own work environment.
I definitely recommend this book to Java Developers who need to better communicate their ideas to groups of other developers. After reading this, there are other references should you need to 'go down the UML Rabbit Hole' a little deeper. this book is better first though, because it puts the relevant diagrams into practical context.
I love the liberal use of source code throughout this book. We model in order to write code and Bob Martin clearly presents that perspective in this book. If code is the goal then it is worthwhile understanding the relationship between our models and our code. While all of the example code is in Java I'd still recommend this book to anyone who wants to learn more about modeling and who has even a passing familiarity with Java. C++ or other programmers should have no problem reading it, for example.
I like that the author goes beyond just describing each of the UML diagrams and takes the opportunity to teach good design while he's at it. As just one example, the "Single Responsibility Principle (SRP)" is discussed. This principle tells us that "a class should have only one reason to change." In other words, don't put everything into one class. That's pretty obvious but it's still a common mistake. The book shows a brief snippet of Java code that violates this principle and then shows the UML for how to design it better. More importantly, we're told how to recognize this problem in UML diagrams we create or inherit.
This book addresses one of the big problems I've had with many other UML books--it tells the reader right upfront that not all diagrams are equally important. I love that the author tells us things like that "in the last decade I think I have drawn less than a dozen object diagrams of this kind." That's great to know! Because many other books try to cover every diagram and modeling technique they all end up appearing equally important. In this book Bob Martin tells us that he's only going to cover what we really need to know to be better Java programmers. He achieves that goal with flying colors.