The title of the book did not imply that this book also actually covers how to write good stories, and gives an overall picture how to start and how tThe title of the book did not imply that this book also actually covers how to write good stories, and gives an overall picture how to start and how to deliver the end result from an agile perspective (which are presented well enough). If you are already familiar with those topics and are actually looking to delve more in-depth into user story mapping (with great examples), then this might not be it. It also repeats itself sometimes. I get that some things bear repeating, but still, it's a bit much....more
If you bought this, then you've wasted money, regardless of your level of expertise.
If you're a novice who's just starting out or a developer who wantIf you bought this, then you've wasted money, regardless of your level of expertise.
If you're a novice who's just starting out or a developer who wants to find out more about best practices, find books that target the areas you're looking to improve on; they will be way more useful by providing concrete and specific examples.
If you're an expert looking for a refresher, just about any software development blogs, sites, or forums that you've been following (you are doing this, right?) will give you better value.
The 97 things are each told in a max of 2 pages - very little room for anything more than a generic discussion. They range from common sense and popular practices to technical challenges and domain expertise. I doubt any professional developer would find even half of these immediately relevant and applicable to their current work/role. They just cover too many areas in too few details.
I'm not saying the advice is bad (although I did find myself shaking my head at a couple), most are good valid advice - I'm just saying this is a poor way to acquire them....more
This is a book that one could get started on the idea of "good code" - clean, readable, elegant, simple, easy-to-test, etc. It has the usual stuff thaThis is a book that one could get started on the idea of "good code" - clean, readable, elegant, simple, easy-to-test, etc. It has the usual stuff that you'd expect - good naming convention, testable code, single responsibility, short classes, short methods - but I feel like it takes them on overdose, going to extremes (IMHO) such as setting short explicit lengths, forbidding certain constructs, and what seems like refactoring for the sake of it.
I'd actually recommend other books like the Pragmatic Programmer or Code Complete; there's something about the way this book reads that irks me. I think it's more useful to highlight the attributes that clean code should have (which this book does do), then it is to declare outright what is "good" and what is "bad" (even in subjective areas like readability, comments, and formatting).
To their credit, the author(s) did state right out at the start that these are their very personal preferences, so that's all right - I'm just disagreeing on some of the more subjective areas.
Also a plus are a few actual and simple scenarios/use cases to show code clean up in action, but they aren't exactly really tricky bits of code, but rather straightforward examples - very good for developers new to the concept of clean code, but less so for developers already familiar with the basic ideas....more
Started this book a long while ago but never finished until recently, but I mostly just skimmed the last 3 chapters, which were practical examples as Started this book a long while ago but never finished until recently, but I mostly just skimmed the last 3 chapters, which were practical examples as well as a conclusion.
A lot of tools and technologies mentioned in the book have undergone many changes, but I think the concepts remained the same. The concepts espoused by the book still remains relevant - something a lot of Java programmers today still fail to grasp. Things like keeping things simple, don't over-engineer, use the right tools, etc.
The book is a bit misnamed though. Yes, it does sort of explain how you can code better, faster, and lighter in Java, but there isn't really that much depth here, something more for the less experienced crowd. So don't go expecting performance-tuning advice or complexity comparisons. It's more accurately described as how to go about designing and developing a piece of software while avoiding some common pitfalls....more
Been reading this on and off for a while now. I would put this on the "must read" shelf of anyone involved in the development side of software engineeBeen reading this on and off for a while now. I would put this on the "must read" shelf of anyone involved in the development side of software engineering, including programmers, designers, architects, even development managers. It presents a lot of important points and topics that some developers sort of know or understand but never clearly defined and put forth. There are best practices on patterns, approaches to design and development, architecture, and communication.
It takes OO development up to a new level, expanding on the generic technical ideas into the realm of domain knowledge. It's about closing the gap of understanding between business users, project owners, and and the developers.
The concepts presented take some time to absorb and are best learned when put in actual practice. It's not easy to digest but as you glean bits and pieces there, sometimes it's like, "I know doing this way always felt right", and now the book explains why it felt right. Some of the explanations are rather abstract (there are very specific examples throughout the book) for things that are hard to define, so I'd say I found it difficult to relate to things where I had no practical experience. Still, I come away from this book with a good understanding of the benefits of placing high importance on the correctness and representational value of domain model....more
This was a pretty comprehensive (if over-wordy) book back when I was in university. It tries to highlight the current best practices of software develThis was a pretty comprehensive (if over-wordy) book back when I was in university. It tries to highlight the current best practices of software development methodology. Unfortunately, it probably doesn't highlight the really up-to-date stuff. Even back then it was more focused on structured design rather than object-oriented best practices, such as doing white box testing and data flow diagrams. There are some gems in there, like the discussions on metrics and formal methods, but the writing is somewhat verbose, making it difficult to sift through....more
This is considered a bible for OO design by some. This book defines many common design patterns. The book begins with a case study that attempts to ilThis is considered a bible for OO design by some. This book defines many common design patterns. The book begins with a case study that attempts to illustrate how the decision to apply a particular design pattern came into play, which was a nice touch. The subsequent chapters each deal with a design pattern, grouped by its type, that describes the problem and solution followed by benefit-cost analysis and some examples.
The book is not a good read, compared to several other books on design pattern. It functions more as a reference guide. The book feels a bit dated by today's standards and the code samples are primarily in C++. I found myself mostly skipping the code samples (they're not hard to follow, just unnecessary for me) and just read the analysis of a pattern, as I'm already familiar with many of the patterns and am just looking for points that I may already have missed....more
Refactoring explained. This book is probably a must-read for all software developers who wants to better themselves. It formalises refactoring reasonsRefactoring explained. This book is probably a must-read for all software developers who wants to better themselves. It formalises refactoring reasons and methods into a detailed, yet simple-to-read manner. It helps point out code smells, highlights the obvious (the so-called common sense) to possibly very raw developers, advocates testing, as well as providing seeds and ideas for future development work. This is a really good companion to any notable book on design patterns....more
A fun book with a rather irreverent style that intros the many common and not-so-common design patterns. It also provides a good basis for learning obA fun book with a rather irreverent style that intros the many common and not-so-common design patterns. It also provides a good basis for learning object-oriented methodology as well as MVC architecture. While the book is fun to read and the examples cute, you may find it a shortcoming that it does not have much in the way of real-world problems. It explains the good and bad of patterns in detail, but it is somewhat lacking in teaching you which pattern best fits a particular use case....more
Extreme Programming (XP) is a development methodology that acknowledges that both developers customers matter. It acknowledges that people have strengExtreme Programming (XP) is a development methodology that acknowledges that both developers customers matter. It acknowledges that people have strengths and weaknesses, and that it chooses to work with those weaknesses rather than against it. This is in contrast to most of the traditional software development methodologies, where emphasis in placed mostly on processes.
This book provides a balanced introduction and explanation of XP. Even as it espouses the good, it also highlights limitations. The goal of the book, as the title suggests, is mainly the help readers understand XP and to decide for themselves whether it is suitable for what they're doing.
For such a topic, the book is surprisingly easy to read. It is very direct and straight to the point, making it easy to digest in small bites....more
This book is a pretty good recommendation for readers new to Seam. It reads well as a tutorial sort of book, from front to back. It starts with easy tThis book is a pretty good recommendation for readers new to Seam. It reads well as a tutorial sort of book, from front to back. It starts with easy topics and gradually moves to more advanced topics. As a reference book though, I find that it's not particularly suitable as it does not cover in-depth details. Maybe it's just me as I found myself searching often for things regarding Seam not even mentioned by the book....more
A great book presenting the best practices of what it takes to be a great developer. I'm reading the book while already knowing quite a bit of the topA great book presenting the best practices of what it takes to be a great developer. I'm reading the book while already knowing quite a bit of the topics discussed, but the book still managed to surprise with little bits of additional insight or perspective. I find the way the things are discussed to be very accessible and fun to read. Every developer looking to learn about best practices (and not just to blindly follow them, but understand the principles behind them) should read this book (among others)....more
It's a great book for fresher developers, as it contains a lot of practices and hard facts to back them up. I''m already aware of quite of bit that thIt's a great book for fresher developers, as it contains a lot of practices and hard facts to back them up. I''m already aware of quite of bit that the book advocates so I wouldn't get as much out of it as a new developer. But having said that, I did get to learn bits and pieces here and there of stuff I hadn't thought about, so it's good. I guess the downside about this book is that it can be pretty long-winded in trying to explain why a certain practice is a good practice....more
Loading...
