Righting Software

If you are an application developer who has been taking requirements from a lead developer or architect this book and it's advice is for you. Take the next step and become not just a developer but the designer. This book is also a must read for BA's and Dev managers. It's brings you in alignment with your developers. If you are a lead developer or architect, this book might help with something's you struggle with and also help you develop your lesson experience developers. All around, some great advice in this book.

The only book I keep more or less permanently on my desktop. Here's why.Effective Decision-Making Tool------------------------------------It has become my trusted reference source for navigating a decision tree with too many branches. This tree I found out stands behind any software system, whether we like to acknowledge it or not.The book has saved me many lost hours spent spiraling down rabbit holes, exploring a never-ending list of "viable" options, doubting my decisions (and biases), and only moving ahead under the threat of a deadline. Even then, often, by making a "coin toss" decision and hoping for the best.In short, it keeps me away from the infamous analysis paralysis, through proven and objective techniques for decision making.The answer is in there. Reread it.--------------------------------------Like many of Juval's other works, the book itself comprises of many layers. Parts that seem as fluff at first pass, surfaces as essential, and meaningful on subsequent reads.Even after fully embracing The Method and thought I got a good grasp on it, I often stumbled on roadblocks, when applying in the real world. At that point, I would pick up the book and end up, most of the time, finding the answer hidden behind a single word or sentence that I didn't pay much attention to before.Teaches Critical Thinking and Antifragility------------------------------------------------I was apprehensive during my first engagement with Juval's teachings as they go against the prevailing trend in the industry and more significantly against my own beliefs that guided my professional career until then. But once I managed to put my ego aside and welcomed divergent ideas, I could see the flaws in many of my ways and fragile aspects of my previous work. It trained me on being more critical towards my own decisions and provided the integrity required to back the ones that remain standing.On the con-side-------------------Due to the heavy loading with crucial information, finding what you need can sometimes be a pain. That's why I ended up having to get both the printed and later the Kindle edition (the latter allowing me to do a quick search for specific terms).Additionally, once you've been exposed to The Method through one of the masterclasses Juval teaches, the book's value gets a considerable boost. However, it may have the opposite effect if this is your first contact with these concepts, thus not getting the full benefit of Righting Software.

If you want to secure your future with a career in the computer software industry, this book is a must for your library. Unlike traditional approaches to software system development, this book teaches you how to design and develop software systems using engineering principles. I have been involved in software development for well over 20 years and I have seen company after company, team after team, struggle (more often fail) to deliver quality projects on time and on budget. I did Waterfall, Extreme Programming, and various Agile methodologies for many years before being introduced to Juval Lowy's "Method". I was a Certified Scrum Master and Certified Scaled Agile (SAFe) Practitioner. All of these have tremendous shortcomings. If you have tried them, you know what I am talking about. Whether you are a programmer, analyst, architect, manager, new or experienced, I highly suggest you make some time, sit back with an open mind and read this book. You may have to read it two or three times because it will likely challenge everything you ever thought you knew or have heard about software system development.Thankfully, this is not a book about theory, concept or philosophy. Instead, it is a book that teaches a proven, systematic approach to building software systems that is far superior to any other current software development life cycle model in existence.

I've spent my entire career in software development and have been architecting solutions now for a couple decades. I can definitely say that many of the most valuable lessons I've learned along the way have been the hard way: by make spectacular mistakes that have resulted in applications that began to show their limits as the time came for things that are increasingly common, now that we are working on web/cloud environments, issues like scalability and security that can rise to the forefront almost immediately. Gone are the days of desktop computing where the worst you typically had to deal with were dll mismatches (and I don't miss those days!).This book was recommended to me by a friend I respect and, I have to say, it was like a thunderbolt.Since I have made many of the same mistakes the author outlines I could instantly see his points - and thus his solutions for avoiding them using volatility-based decomposition. They say memories based on strong emotions are those that stick with you. I'm here to confess to you that I have quite a few memories that I'll never forget from architecture decisions that later came to rear their ugly heads.If you're like me and your best growth experiences seem to be predicated by spectacular failures I highly recommend you pick up this book, read it thoroughly, and keep it close by for reference. Better: if you're new to software architecture, pick up this book now and you'll be able to avoid the pain and humiliation I've had to suffer by learning how to design correctly the first time!

A book of two distinct parts.The last 300 pages focus in great depth on how to plan a project. Despite Löwy's assertion that this is a responsibility of the software architect, everywhere I have worked this is a responsibility of the project (or programme) manager; in fact I've never even come across the idea before that the architect should be responsible for this (rather than just involved in it). So as an architect I'm not best-placed to judge whether the project design advice is good, but it goes into great detail and nothing struck me as obviously wrong.Only the first 150 pages cover the design of software systems, and Löwy doesn't go into nearly the same depth here. He suggests we avoid a common approach (functional decomposition) and instead follow his "Method" (where volatility is the primary consideration); the idea is interesting but there is almost no discussion of how to put it in practice (e.g. how to identify areas of volatility and stability, or how to decide which areas to combine and which to split), it seems that to find out you would need to take one of his training courses.So if you are interested in learning more about how to deliver software systems you might find this book very helpful, but if you want to learn more about how to design software systems I doubt you'll get a lot of value for your money.

Well, what can I say? I've been waiting for this for a long time. You know sometimes, you like an idea because "that's exactly how I've always thought it should be", but in this case, it's quite the opposite.As time passed after the architect's masterclass course, it was proving difficult to retain the ideas, but this brought them back clearer.The only danger is, if the industry moves from functional to volatility based decomposition, where will all the projects to fix bad Solutions come from? :)

All you have in this book are explanations of how not to design software (functional decomposition), but then it fails to give a clear picture on how to achieve composite design. First you'll have a great explanation on how to find volatilities and how to encapsulate them in components (around chapter 2), but after that it starts to explain how to map those volatilities to architecture components and, in my opinion, starts to contradict itself about the Managers vs Engines ratio. Then you fail and fail and fail trying again because the book is always "if don't achieve this and that is because you are doing functional composition".I can't recommend this book, you are better reading something about reactive design and DDD.

this book and its cover texts starts with self-praise of the highest level. while reading, I found it hard to find ground for this praise - unless you are a total fool at programming you should know how to avoid some or most of the described problems. someone with that much praise should deliver more than excel graphs - and I finally got the impression that the overall content could have been subsumed into but a fex chapters, or a much shorter text even.

Nem comecei a ler direito, e percebi que a qualidade das páginas do livro são horríveis. Um papel de baixíssima qualidade que amassa ao folhear. Fiquei decepcionado