Customer Reviews

Code Craft: The Practice of Writing Excellent Code

5 star:		(10)
4 star:		(3)
3 star:		(0)
2 star:		(0)
1 star:		(3)

 

 

After reading the good, despite few, amazon reviews of this book i decided to pick it up. I'm a big fan of books that teach one how to become a better programmer. Unfortunately, i wasn't too impressed by this one. The author didn't seem to have anything super insightful or groundbreaking to share with us. He gave a description of what he considers to be good code/coders along with a really brief description of a lot of software related tools, paradigms, and 'types' of programmers.

Unfortunately he doesn't really say anything that hasn't been said. His code examples are notably poor. In Steve McConnels book, "Code Complete" he criticizes programming books for using fibonacci as an example of recursion. He criticizes it because it's not something that software developers find themselves doing often. I have the same complaint with most of the code examples in this book (so maybe it is good there are so few). It felt like my high school java teacher (who had neither a CS degree or programming experience) wrote up the code samples. You'll quickly be annoyed by the simplicity of the mistakes and concepts that he is trying to express.

As you read this book you'll find things you agree and disagree with, and you'll just want to say OK. you won't run to your computer wanting to implement them. You also won't run to your friends telling them you've found a new way to do something. I guess that is my major problem with this book, there's nothing really special about it. I also found myself wondering 'why is this important?' throughout the book quite a bit.

I found another thing in this book to be insulting, the Good Programmers Bad Programmers section after each chapter. If i didn't know the difference between a good programmer and a bad programmer i wouldn't have bought the book. They are all very similar and obvious.

I would definitely recommend the following books over it:
Code Complete
Refactoring
Pragmatic Programmer
while this book does cover some things these books say, not enough to replace any one of them, and reading any of these will provide insights this book cannot.

I was at the library and this happened to be next to another book that I wanted, so I picked it up too.

And wow, it's rare that I am this disappointed in a book. The content is very thin. It sounds like it was completely gathered from secondary sources, e.g. reading other books about software engineering. It doesn't sound like the result of actual experience.

Every page is filled with platitudes without any examples of real experience backing it up. I'll grant that he has assembled an extraordinarly wide range of *terms* and terminology. It looks like he has tried to shove 3 sentences about every topic in software into a single book. Unfortunately, this ultimately makes for a book with little use.

Another sticking point is the writing style. It comes off like the author is an annoying guy trying to be funny and trying to be your friend. The first sentence irritated me: "What's in it for me? Programming is your passion. It's sad, but it's true."

Huh? Why is it sad that programming is one's passion??? There are similar head-scratchers elsewhere in the book. He also devotes a section to talking about the various types of "code monkeys". And the last type is "You. In the interest of politeness, we'll say no more about this curious beast. Sadly, some people are beyond help..." What? The reader is beyond help? If I pretend for a minute that he's not insulting me, then I still don't know what he's trying to say. This book is incoherent.

And what's with all the reviews below that read like advertisements? Give me a break. It looks like a lot of the author's friends are spamming Amazon's reviews.

I recommend reading Joel Spolsky's books for real, specific insights on programming and the software development process, earned from experience, written in a much clearer and more entertaining style.

I'm also reading Jon Bentley's "Programming Pearls" now.

This one is a very good book. It is essentially a book in natural philosophy, not quite "scientific", coming from observation to show you a little bit of everything. An insight to the entire world of programming if you like.

It goes from bottom up, from coding style through techniques and tools to paradigms and architecture. A lot (A LOT) of things explained, briefly, but perfectly understandable. It lacks any analysis or in-depth discussion, but that is on purpose.

Not that many things for an experienced programmer to learn from this book though. To a point where it is boring. It took me longer to read this book through than many others, because I knew much of it in the first place.

The language of the book, the author really is in for wordplay and puns of all sorts, it's all over the place. And although I do believe that proficiency (and desire to excel) in written language is a sure indication of a great programmer, this is not always to the book's best. It sure doesn't read like a textbook, but that's ok. There were a few really good jokes, but most of it is just wordplay for its own sake. For example,

[quote]
This is the really nasty one - when your program isn't pushing up the daisies, just pining for the fjords.
[/quote]

Look, I know what "pushing up the daisies" mean, and I can deduce the meaning for "pining for the fjords" from the context, but having it written like that doesn't really help.

Like some other reviewer, I also didn't like the "good programmers" vs. "bad programmers" checklists. See, being a good programmer (aren't we all ?), I wouldn't know how bad programmers think, thus any attempt to declare "bad programmers do that" would be at best a guess.

What's really good about this book, is that it goes under a positive "do as I do" key, not a negative "don't do as I say", seen much more frequently. I'd guess that the guy is really keen on what he's doing, and you can feel it in his book.

I was pleased to see that yet another author's word supports my belief in that programming is simply patience, discipline and common sense. Oh, and PRACTICE.

Anyhow, a great book for a beginning pragmatic programmer.

I have two comments.
First, do not expect technical details on this book. There isn't. Second, the only paragraph that is really good is on page 461 and it says: "Find the classic books of the field". This is not one of those. He recommends and I agree almost completely:
* Code Complete
* Design Patterns: Elements of reusable object-oriented software
* The mythical man-month
* The psychology of computer programming
* The practice of programming
* Peopleware
* The pragmatic programmer
* refactoring

I do not thing that "Code Craft" is one of those.

Almost any programmer can program. That's more or less the definition of the word. It's pretty rare (but not unheard of) to find a C++ programmer who doesn't know C++.

So what's the difference between a good programmer and a bad one? Usually it's all of the thousands of disparate things that a programmer needs to know to be effective that don't deal with the programming language itself. Things such as design principles, coding standards, testing strategies, understanding of tools, and general development philosophy.

Those are the topics of this book. "Code Craft" won't teach you how to build generic collection classes and optimized tree search routines in Visual Basic or any other language. Instead it focuses on the myriad skills a good programmer uses while building an application. Things such as defensive programming, how to format code, using meaningful names, testing, and source code control. It describes different kinds of programmers and project organizations, and explains how to with the strengths and around their weaknesses. It explains how to write specifications, perform code reviews, and estimate project lengths.

Pete Goodliffe is an experienced professional developer and it shows in the book's right-on-the-money tips. His advice and experiences (as shown in frequent interesting sidebars) agree with mine in almost every way. Of the many tips in this book, the only one I found that I don't agree with is the idea that you should write the fewest possible comments, including only those that are absolutely necessary to explain the code.

Even that minor criticism demonstrates why I think you should buy this book: to get different points of view. There are several books available that deal with these sorts of higher-level programming issues including "Code Complete" by Steve McConnell and "Writing Solid Code" by Steve Maguire. They all follow the same general theme but each reflects the personal experiences of the authors.

Pete Goodliffe's writing style is fact-filled, easy to read, and downright entertaining. It's perfect for reading on the bus, during the half hour before a meeting when you don't really have time to start writing a new subroutine, and sitting behind the ficus during those awkward cocktail parties that marketing throws to impress customers.

This is a language-neutral book. It focuses a bit on C++ and similar languages but there's plenty of material to benefit developers using any language. Buy it and read it as you have time. If you pick up even a single new tip, it will be well worth the effort.

It is rare these days for me to come across a "how to write great code" book that I actually enjoy as much as this one. The reason for this is simple. I do not believe that there is just one way to write well crafted code. Face it we all have our opinions on how code should be written and we are all correct to some extent. However the author Pete Goodliffe does an excellent job in explaining how he feels how we should all write well written code. You may end up disagreeing with what he has to say but I assure you that the journey will be entertaining and thought provoking as well.

One of the best aspects of this book is the generous use of questions that are supposed to foster discussion with either your peers or someone you may be mentoring. The questions are designed to force the newbies to overcome some of their previous misconceptions and apprehensiveness in the process of developing great code. For example a new software developer may not understand the benefits of code reviews so reviewing this chapter before beginning this process could make the process much easier for everyone involved.

The only aspect of this book that I did not particularly enjoy is the use of derogative labels applied to generalized categories of workers. This really does not help in a team environment and rather I believe would create deeper divisions between those that you work with. Rather team building should be more emphasized in this book as that would make the working environment just that more enjoyable. Just my opinion of course.

There are two types of programmers in the world - those that do what this book suggests and trainee programmers who haven't finished learning it all yet.

All of the information in the book is useful information that any programmer needs to know regardless of what programming languages that they use. With over 30 years of programming experience myself I can say that there is nothing in the book that I wasn't already at least aware of but it took me a long time to gradually discover all of that information and now here it all is in one well written and entertaining book. Now there is no excuse for a programmer to not know the right way to write programs that will function correctly, interface with other programs the right way, and be easy to maintain.

The author of this book really understands all of the aspects of programming (which of course is a lot more than just writing code). The book covers all of these aspects one at a time in a logical order looking first at how that aspect ought to be handled in an ideal world and then at what compromises that you may decide that you have to make in order to apply it to a given real world situation. Also discussed is how to handle legacy code that wasn't written properly and how to determine when you should or shouldn't rewrite it.

The author's writing style makes the information being presented easy to understand and apply while also making the book one that is interesting to read. There is plenty of humour in the book as well and I laughed a number of times particularly at some of the monkey cartoons used to illustrate the points made by each chapter (a job that they do extremely well).

What are you doing still here reading this review - go get the book and read that instead.

Written in a text book style, this 600 page tome covers the many influences on code excellence and provides a range of improvement suggestions for personal and team exploration for those interested in reducing the cost and frustration associated with poorly written software. The book of 24 chapters is split into six sections with the first getting straight into techniques for writing better code. The second section looks at how utilities, testing, debugging, building, optimisation and security considerations can be best used to improve software. Section three examines influence of software architecture and design and how code suffers over its lifetime. How individual and teamwork coding practices influence code excellence are explored in section four, along with a chapter on source control. Section five looks at the development process and the influence of specifications, code reviews and project planning and estimation on code excellence. The final section looks at development methodologies, programming disciplines and how to continue the journey to perfection.

Key concepts are highlighted throughout and the inclusion of instructive 'war stories' plus '10,000 monkeys' cartoons break up the text. There are plenty of references included - both internal cross-references and external references, with quite a few of the latter being seminal works in the evolution of software engineering. At the end of each chapter summary, there is a dot point summary of good vs bad programmer behaviors relevant to the chapter, plus a reflective section that assists with the review of the chapter. The reflective section is supported by almost 100 pages in an Answers and Discussion section at the end of the book, which is well worth reading. The index is rather light-on at on 16 pages, however. The techniques outlined in this book are relevant irrespective of platform, programming language, methodology or software licensing philosophy.

While of most use to a computer science student or a new hire in software development, anyone involved in the development and maintenance of software that wishes to improve productivity and software quality throughout the software lifecycle - not to forget the all important work environment, will benefit from this book. I would certainly like to work in a company that adopted this book as a framework for continuous improvement.

Some books tell you how to program in some language. "Code Craft" tells you how to do it well in all computer languages.

"Code Craft" is not focused to a specific discipline or computer language. All that you learn from it can be applied to any language, let it be Pascal, Java, C, or whatever.

The author, Pete Goodliffe, is an expert developer with many years of experience at many positions in the chain of software development. His book is then written from a practical point of view and from all that he learned in his professional career.

The book assumes that you have a solid knowledge of programming. It doesn't want to tell you how to program, but it will tell you how to do it well.
This means: make bug-less software, and that is robust, and gives you satisfaction and no problems.

"Code Craft" also tells you something that you couldn't learn in your studies: how to efficiently work in the software industry. Skills like working in a team, making code that is documented in a way that others can understand... These skills will help you, as the book says, to "survive in the software factory".

Even the human factor has its own chapters in this book, when it tells you how to recognize some kinds of programmers in your team, and what you can learn from them. And if you feel that you belong to one or more of these groups, it tells you how to improve and take advantage from your virtues, and how to avoid your flaws.

Not only an instructive book, its pages are also full of sense of humor, with some comic strips that programmers will enjoy.

Reading "Code Craft" you will learn the practical side of programming into the real world of a team. All phases and facets of application programming are described: comments, documentation, optimization, design patterns and disciplines, team organization, development tools...

This book is for you if you want to work as a professional programmer in the software industry. It will save you from being fired or being a pain for your team, or at least will help you to avoid that.

It is also good if you are part of an open source development team, to learn how to work together with others, reduce bugs in your code, and make code that can be easily understood by an always changing and huge team of programmers.

Even if you are a "lone wolf" programmer, this book is also for you, because it will reduce your headaches: it will tell you how to spend more time developing and less time fixing bugs and security holes.

If you're a professional software engineer, looking for advanced topics and ideas, this book is not for you. (Which is why I think some people gave this book a single star - I don't think they weren't the intended audience.) If you're just starting out, and you're looking for just a general guide of what 'good coding practice' means, you'll want to give this one a hard look.

This book won't turn you into a good coder over night -- but it'll help you start on the journey, if you want to take the stuff you learned in school and see how it works in the 'real' world. It's not very high level, it's not very complicated. But the first step in the journey is always a small one; and if it gets you thinking about the subject, that's to the benefit of every programmer and every company you will ever work with.