****** - Verified Buyer
4.5
Thoughtful programmers often discuss "why is software terrible" and "why can't we be like the real engineers?" This is a thoughtful book-length answer, from a reasonably senior engineer with a wide breadth of experience.I am not certain who the right audience is. The book makes some gestures at being accessible to non-programmers, but I suspect they would find parts of it heavy going. (E.g., the description of buffer overflows in C programs.) If you have a semester or two of programming, or some experience writing scripts and suchlike, you probably have enough background. On the other end, I am a senior software engineer and I have a PhD in computer science with a particular focus in software engineering and social aspects of programming. So I am probably about as expert a reader as there is. I felt like a third of the book was review for me, another third was an interesting and useful presentation of stuff I half-understood, and another third was genuinely new insight.The book opens with a biographical pattern, following the author as he moved from PC BASIC, to Princeton, to working for a software company, to Microsoft. The biographical structure is mostly a hook to give the author's perception of the development habits in these different communities and the problems they each produce. Old-style BASIC, for instance, inevitably degenerates into spaghetti code; C tends towards subtle string and memory problems, small software companies used to have a culture of "throw it over the fence once it compiles and seems to work for the dev", and Microsoft in the 1990s tended to emphasize trivial style rather than deep design in code reviews.The second half of the book breaks from biography and is a series of focused studies of various topics. I thought this was the stronger part of the book. The author points out that we *do* know a number of things that would help -- systematic structured code-reviews with definite things to look at, better languages, better tools, formal methods, etc -- and we mostly just don't bother. A great deal was worked out in careful scientific studies in the 1970s by old-line hardware companies -- and then the microcomputer people assumed it didn't apply, were too small to do their own studies, and just forgot about it.I wish the author dug a little deeper into the social dynamics here. Why are programmers so resistant to best practices? Why don't engineering managers and CTOs push? Yeah it's more fun to code than to write test plans, but debugging production failures is even worse, and probably we'd get used to the test plans. Is it that too many engineers started out self-taught? That academics don't bother to teach software engineering because school assignments are too small?Even without a careful set of recommendations, there's a great deal of thought-provoking material here and I recommend the book highly. You could use this as a good course book in an undergraduate or masters-level software engineering course.It's an adequate book about the evolution of software development technology. It is really about the education of a young code hacker. He explains that he didn't learn anything significant about software engineering principles and techniques in college, so he had to learn them as a professional software developer. That's good, because part of being a professional is "lifelong learning" -- keeping up with advances in a rapidly changing field.It's good to see references to the classic books on software engineering, books that have many good lessons for the younger generation of software professionals -- Software Productivity by Harlan Mills, The Mythical Man-Month by Fred Brooks, Programming Pearls by Jon Bentley, and Design Patterns by Erich Gamma et.al.Adam doesn't address the issues of teamwork in software projects -- his mostly focused on technical issues about API design and implementation. The really hard issues in software quality are the "soft issues of software development." Steve McConnell has some good coverage of these topics in his book Code Complete, but it is also useful to refer to books like Peopleware by Tom DeMarco and Tim Lister and Journey of the Software Professional by Luke Hohmann.I would give this book a higher rating, but I think that the critiques of Object Oriented Programming (in chapter 6), software architecture (in chapter 7), and agile development (in chapter 9) are relatively weak. Each of these chapters sets up a "strawman" -- an unrealistic example of the technology being used in an unrealistic way. Adam is entitled to his opinion, but any OO design expert, professional software architect, or Agile coach would probably scoff at his complaints. Adam shows examples of complex inheritance hierarchies, but good designers avoid this level of complication in their C++ or Java code, and they still get the benefit of strong encapsulation in their classes. (Just do a Google search on "prefer composition over inheritance" for some useful opinions.) Adam correctly points out that many companies have junior software designers that are mislabeled as "architects," but research groups like the Software Engineering Institute have studies that demonstrate the value in having a well-documented high-level design structure for any long-lived software product. Good Agile development has matured a lot since the Agile Manifesto and Extreme Programming, and many companies are using Agile methods successfully for mission critical applications for years.Adam tries to make seven recommendations to make improvements in his final chapter. One of them is an excellent practical suggestions: "Teach students to work with larger pieces of software." Several of the other suggestions are reasonable ideas but hard to implement (such as "Emphasize readable code.") Two of the recommendations are not good at all (gradually introduce certification or licensing for software developers, move specialized topics such as databases out of the undergrad computer science curriculum). Software is a field that is changing too fast, and there is a risk that any specific certification or university curriculum guidelines would become outdated in just a few years.I've been programming for a long time and have also started to wonder what it is that makes software so much harder and less reliable than it should be. Unlike the author, I didn't learn any programming prior to college but I did spend a lot of time tinkering in the lab. I agree with his assessment that we're all self-taught and we're all reinventing the wheel time and time again, but I do not feel our industry can say "this is how you do it" for a lot of what we do in our daily jobs, except at the lowest level of daily coding.A lot of what we're doing in the industry is completely new or someone trying to replace an Excel spreadsheet (or that's been my impression). You somewhat need a cowboy mentality to tackle the unknown, but the author's right that we need to start tackling these sorts of problems with research and not handing them to interns, pushing them to production and then hiring a team of senior engineers to support them. But these are just opinions based on personal experience.This book does come with a certain retro vibe and seasoned engineers might appreciate the trip down memory lane captured early in a book. To be honest, I'd rather work along side the kid who spent their evenings tracking down bugs in the lab over some stuff academic or "specialist" any day. I was left wondering at the end of the book "what was the point of me reading this?" Perhaps the author's only hope was to inspire us to go read some old books and papers and maybe we might learn something... Overall the author came across as having lost hope we'll ever find a better way to write software or even if we do find it our industry will never be motivated to use it, simply because the demand for developers and short turnaround are too great right now. I am glad the author avoided proposing a solution, though.Me encantó. Me veo reflejado en este libro. Lo que si es que la propuesta para mejorar los proyectos futuros de desarrollo de software no es muy clara.
