Customer Reviews

After the Gold Rush: Creating a True Profession of Software Engineering (DV-Best Practices)

5 star:		(15)
4 star:		(12)
3 star:		(3)
2 star:		(5)
1 star:		(6)

 

 

Steve McConnell comes through again. In this short collection of essays, he argues convincingly that the software industry can and must change drastically. The industry's "code-and-fix" practices, which have over and over proved ineffective and even dangerous, have to go. The image of the heroic programming genius, saving the dysfunctional organization over and over from behind a wall of empty pizza boxes and soda cans, must go as well. Empty and foolish heroism must be replaced by good processes, patient planning, and good engineering practice.

McConnell argues that in order for this change to occur, a proper "profession" of software engineering must be created. Such a profession would, above all, aid the diffusion of effective software engineering practices. In addition, a profession backed by universities, professional guilds, and a system of certification would make developers accountable for the software they create, and would allow them to take a stand against clueless management who want systems "done yesterday"--whatever the ultimate cost or detrimental effect on quality.

My only complaint is that McConnell ignores one important factor in software: the impatience of contemporary investors and financial professionals. The short-term focus of these parties is hurting quality in every industry, including software. Perhaps the only way new companies will be able to battle their influence will be to remain private--a difficult sacrifice that will require character verging on stubbornness.

For an interesting pairing, you may want to read this book alongside Mark Minasi's "The Software Conspriracy."

Steve McConnel is right on the money here. Software Engineering needs to mature into a real "profession", in the sense the engineers, doctors, and lawyers belong to a "profession". This is the basic point of the book. As McConnell says in the Introduction, "It's time for software development to grow up."

However, contrary to some other reviews, this book is a lot more that just a rehash of "Rapid Development" (one of McConnell's earlier books, and an essential book in its own right). "After the Gold Rush" does make some points that are also made in "Rapid Development", but the intent and content of "After the Gold Rush" is totally different.

This book is part manifesto, and part roadmap. McConnell puts forth the idea that, despite the proven effectiveness of many fully developed "best practices", the software development industry as a whole continues to ignore them and engage in "code and fix" style development. The software industry, McConnell writes, needs to grow up and start taking on some of the characteristics of more mature professions, especially the engineering profession. After making this point, and backing it up with studies and other empirical data, McConnell proceeds to lay out the qualities that a mature profession possesses, which of those qualities the software industry is lacking, and how we can move forward toward maturity, examining such topics as education, licensing, and ethics.

I feel this is essential reading for any developer. Will this book teach you about coupling and cohesion or show you the ins and outs of running a JAD session? No, that's what "Code Complete" and "Rapid Development" are for (and please read those if you haven't). This book foretells (and I believe will help fulfill) the inevitable future of software engineering as a profession. This book provides a look at what software developers do from a higher perspective, and puts the profession in a broader (even historical) context. It has helped me to consider my job as a software developer from a fresh angle, and to take stock of my role in the future of the profession.

Mr. McConnell's latest book delivers a pitch for certification in software engineering. He makes a reasoned case and provides a little useful historical context. Unlike his other books (Code Complete, Rapid Application Development, and Software Project Survival Guide), this book offers little of direct use to a practitioner. The book aims to accelerate a coming trend, rather than inform its readers about what exists today.

If you are at SW-CMM level zero (never heard of CMM) or level minus one (think it's nonsense), then this may present new concepts - but I found this book to focus on the process of certification and credentials rather than the software process itself.

I found the chapter on professional ethics to be rather humorous, although I doubt this was the author's intention. Look at the miniscule number of doctors or lawyers that lose certification. In practice, professional certification is used to defend established players from newcomers, particularly foreign newcomers. This will be a big issue given the large number of first-generation immigrants making huge contributions to software in North America. I think in this area, as well as the discussion on the "Chasm" (see Geoffrey Moore) in adopting practices, the author could take a stab at some conclusions, however speculative.

As always, Mr. McConnell's crisp writing style and deep industry knowledge make for a pleasant, informative read; however, I think only people working on setting policy, establishing certification or a defining a curriculum will find the material concretely helpful.

If we truly are an Engineering profession, why haven't we adopted the kinds of process and quality control measures demanded of other Engineering professions, like electrical engineering, mechanical engineering, etc? The answer is maturity.

After working in software for 13 years, I have seen my share of late deadlines, heroic efforts which 'save the day' on a project, weeks worth of code thrown out in favor of another few week rewrite, the list goes on... When was the last time you saw a contractor rip down a building after it was 70% done because they decided the 'basement wasn't good enough'? It happens all the time in software.

With some of the observations this author bases his conclusions on, it felt as if he has worked beside me for years. I don't agree with everything he has to say, but it is compelling and thought provoking in the extreme.

If you have seen projects that routinely go over budget, routinely require heroic efforts, routinely seem to lack requirements, and think 'there must be a better way', then read this book. It took me less than a week of evenings, and it has already become the best thing I've done to create a 'vector of change' within my organization towards better Engineering practices. It's time we all grow up, and act like the real engineers we are.

I've been in this business since March 1982. I've read them all. This is the BEST book you can read on the subject. I know, you get these books, try to read the first chapter, they're poorly written, boring, and grow dust on your shelf. THIS BOOK IS NOT LIKE THAT! If you read ANY book on software process and the problems currently faced by software professionals, this is it! And, in response to "A reader from Deep in the trenches of software development", grow up! Hopefully, dinosaurs like you will die out, just the way Ptolemaic theory died when Copernican theory was adopted. It's unfortunate that the code-and-fix mental disease persists, mostly in the minds of "heroes, ball-hogs, and silver-bullet all-nighter 24/7" infected programmers. I, personally, went to the University of Michigan College of Engineering, and have a degree called "Computer Engineering". The software field requires all practitioners to elevate themselves to Engineers. One would never dig the foundation for a huge structure without first having solid requirements, design review, blueprints, and permits. The current software field still goes right to digging. The software engineering portion of our profession is the most important: get those requirements, get buy-in, do a design, get it approved. Then, once you're done with that, you can get a programmer to code it! Those of you out there that still do not believe in software process enabling you to meet your goals better than the retched code-and-fix mentality, I ask that you follow leaders with a process and examine the results, or do the rest of us a favor and leave the field.

I have worked in IT for over 20 years, and own McConnels Code Complete and Rapid Application Development. Those books were great, this fell very short of that.. way short.

Steve McConnel writes well, and is nicely organized, and points out things that should be known (if you read his other books, you read material in this book). The book is a fast read, and has information of value (which is in his other books). If you do not have his other books - then yes, you could find value in this (and it is much more compact - not so code oriented - a manager, unfamiliar with McConnell would be a good audience for this book).

This book did seem more like evangalizing the direction of establishing a license of the software professional. His other books were more on how to do that, this seemed like an extended plea to establish a licencing of the profession. It seems well intended, but not highly practical, and so for me it was very dissapointing.

Perhaps Certification is a start towards establishing a "license", and some people view that as a way of proving you know something without really having experience - (I recommend certifications myself - knowledge combined with real world experience is a good thing in IT).

If you have his other books, you can pass by this one with hardly noticing, unless this is your introduction to McConnell and you need a fast reading book.

The Tar Pit. Software Dinosaurs. Fool's Gold. Orphans Preferred. Software Engineering is Not Computer Science. These are just a few of the chapter titles from Steve McConnell's latest book, After the Gold Rush. Perusing the table of contents gives one the impression that this read is going to be a hard-hitting call to action, and it doesn't disappoint.

After writing some of the best coding, management, and process books of the last decade, McConnell is calling for software development to join the ranks of other real professions as a true engineering discipline. I'm a civil engineer by education, and I can confirm that most software development bears no resemblance to the rigorous discipline exercised by professional engineers. We as an industry have been walking on the wild side for too long. It's time to settle down and get organized.

The book is a series of essays that take the reader from the problem, to the search for the solution, and finally to a plan for education and certification. Readers of the author's other books won't be surprised by the analysis of the problems facing the software industry. We--collectively--just put out too much bad software with too many bugs, are still stuck with the Not Invented Here syndrome, and aren't even focusing on the measures that provide feedback for improvement.

He promotes the Capability Maturity Model for Software (SW-CMM) as a measure of the practices in wide use today. The report is bleak, and makes software disasters like the Denver airport baggage system, as well as failed software upgrades at the IRS and FAA, seem inevitable.

The answer, in overly simplistic terms in this review, is to make software engineering a professional, licensed profession in the same model as civil, mechanical, and electrical engineering. Like those disciplines, this doesn't mean that every practitioner in the field must be educated and licensed as an engineer. But every software project must be signed off by such a professional, who certifies that the project was executed with the proper, rigorous methodologies and built-in safety factors.

Like the construction of a log cabin, there would be no need for every relatively simple software application to undergo such rigorous engineering. But any major application would be required to have an engineer overseeing the process.

This move is long overdue for the profession. Maybe with it, we'll eliminate the number of major software failures that constantly make the news, and software will once again be as reliable and trusted as the Golden Gate Bridge or the Panama Canal.

This book reads like a set of outtakes from the author's excellent "Rapid Development". In fact, some anecdotes, and ideas are repeated from that book without much elaboration. Some interesting insights but some appear to be based on stereotypes.

For example, the author claims that many computer science degree courses disregard that most of their graduates will get software engineering jobs and don't teach them necessary skills. CS departments are aware of this and many do include courses on engineering, or the ethics and practices of a "professional". My degree about 5 years ago had these components.

I really think this book would have its' point made by having been formed into a few articles for DDJ or Communications of the ACM, or an appendix in "Rapid Development". "Journey of the Software Professional" is a heavier read but a lot more rigorous if you are interested in professional issues in software engineering.

An interesting read, if a coworker happens to have a copy lying around, but invest the money in Steve's source material instead - e.g. a copy of "The Capability Maturity Model".

Another well-written, insightful book by Steve McConnell. It makes the case for not only process, but also for a more professional attitude by programmers and the industry in general. Some of his points will be familiar to those who have read his other books, like Software Project Survival Guide, or his columns in IEEE Software. The book offers a good look at where the software industry is headed from somebody who knows.

Another great book in a line of great books from Steve McConnell that puts together a compelling case that it's time for us software developers and the profession as a whole to grow up! This book, starting with the title itself, offers good insight on where the profession is and where it really needs to go. It's a quick read relative to some of Steve's other books (Code Complete, Rapid Development), but still gives good coverage of his premise and a convincing case. Like Code Complete and Rapid Development, this is an important book for any developer/leader who is serious about the profession.