Solid book when you are starting journey of a developer. Great guiding principles but don't be dogmatic about using them. They are useful, but they should not restrict creativity or practicality in problem-solving. The authors, Andrew Hunt and David Thomas, provide invaluable wisdom gleaned from their years of experience in the field. Their insights on "how to think" rather than "what to think" are exceptionally helpful for newcomers.

The book covers a wide range of topics from basic coding practices to effective debugging techniques, and from code optimization to managing your career as a programmer. The engaging writing style, coupled with numerous practical examples, make the book a pleasant read.

One of the key takeaways from the book is that a good programmer is not just about writing code, but about understanding the problem at hand and devising the most efficient solution. This philosophy is repeatedly emphasized throughout the book, highlighting the importance of being a "pragmatic" programmer.

Although the book is targeted primarily at beginners, even seasoned programmers can benefit from the wealth of advice it offers. However, some might argue that the book is somewhat outdated, as it doesn't delve much into recent trends like cloud computing or machine learning. Despite that, I believe the principles the book teaches are timeless and apply to any programming context.

While I recommend this book for its practical wisdom and broad coverage, it's important to remember that it's not a step-by-step coding manual. Instead, it provides a framework to think, behave, and approach problems as a developer.

In summary, The Pragmatic Programmer is a must-read for anyone embarking on a programming career, offering a great foundation on the principles and mindset needed to succeed in this field. ",,,1,0
116114,From Here to Eternity,James Jones,Jones ( )

The advice is good, but there is so much good advice that if one were to implement all the good ideas, simple tasks would never get done. ( )

A great resource

All of the unspoken aspects of software development study skills. And as checklist of hard skills to acquire. I really enjoyed this and will constantly revisit ( )

As I remembered, very good. ( )

The Pragmatic Programmer is still quote current despite the fact that it was published in 1999. The book contains all sorts of useful advice for programmers. Most people, especially those with a *nix background, have probably heard a lot of what they have to say. However, this book emphasizes a lot of good software engineering techniques, describes why the techniques are important, and manages to do this in a readable package.

A very good generalist book full of ideas meant to make your work more robust, easier, and cleaner. Very pragmatic, indeed. If anyone needs the summary (either to find out new information or, if you've read it already, review the ideas), just let me know. ( )

Great questions to ask and themes to follow at any level of software programming. ( )

As an experienced dev I agreed with most of the book (or rather the first third, at which point I stopped reading). However, it felt like there was very little actionable information for me and I'm not sure younger me would have known how to apply the recommendations. ( )

Here's a book for coders without much code, and still valid after nearly 20 years and several generations of software. It's a catalog of productivity practices, not only in coding but also in setting agendas, learning new methods, writing use cases and requirements, making estimates, fixing rather than doing workarounds, automating, documenting and other common project elements. Maybe it's not just for coders after all.

Good, solid advice. However, much of it is already well known and accepted. Nice with different programming languages in the examples (in the 20th Anniversary Edition) ( )

This is one book that all programmers should read, no matter what language they may be developing in. While much of it may seem like common sense, the advice given is often not followed in practise. So, to save yourself a lot of extra work, spend some time to read and absorb the advice given in this. ( )

A very fine book on the basics of programming. Covers a lot of difficult situations a newcomer could face. Also could be useful for the senior programmers just to verify what they've learned through the years. ( )

There's a lot of hype for this book, but I'd rate it as merely "ok". It has a lot of basic advice that is probably useful for beginner programmers; however, if you've been coding for a while, most of the advice will sound like common sense.

Some of the advice is actionable, but some is theoretical or ideological; some parts are language and framework agnostic, while others have become quite dated; there are a few bits of deep, meaningful advice, but mostly, the book consists of fairly simple aphorisms. It even has a detachable pull out with all the sayings.

It's an easy read, but rarely rises above the programming analog of "eat well and exercise regularly".

Some fun (and funny) quotes:

"Don't live with broken windows."

"Use tracer bullets to find the target."

"Prototyping generates disposable code. Tracer code is lean but complete, and forms part of the skeleton of the final system. Think of prototyping as the reconnaissance and intelligence gather that takes place before a single tracer bullet is fired."

"Check their spelling, first automatically and then by hand. After awl, their are spelling miss steaks that the chequer can knot ketch."

"Distributed systems such as EJB are leading the way into a new age of configurable, dynamic systems."

"We who cut mere stones must always be envisioning cathedrals." - Quarry worker's creed

"The limits of language are the limits of one's world." - Ludwig Wittgenstein

( )

A great piece of work which serves as a general guide to good programming. It addresses the craft of writing software irrespective of the domain of application and you can feel that the authors have poured years of their own experience into this text. Although written in 2000 (I read it in 2013) I feel like all the points covered are still relevant in a modern environment. It encourages the reader to be critical, precise and determined in their craft and continuously reiterates the need for constant self-improvement and further learning in this trade. The underlying principles of programming such as modularity and don't repeat yourself are very well explained, and there is plenty of information and tips on debugging, refactoring and testing - it's all in here.

This is an excellent book if you have already programmed a bit and are looking for something to elevate your skills up a notch to a more professional level.

As some of the topics in this book were beyond my scope of understanding on the initial reading, I will definitely be re-reading this in the future once I have gained more experience. ( )

After many years, I finally got around to reading this. I'd already seen much of it, in various locations, so it wasn't as illuminating as it would have been if I had read it in the early 2000's. ( )

An excellent handbook. Useful for everyone who wants to build high quality software. ( )

This was an interesting experience because I don't recall ever reading a computer programming book straight through. I'm in the process of segueing back after a few years away, and this was a good route to take -- once familiar advice packaged succinctly, with enough new and enough detail to stretch me a bit into the modern world. I did not do the exercises at the end of each section. Can I still claim that I read it? This is the sort of book that I would typically have on hand as reference, but a reference book is of course more useful if you kinda know what's in it.

(read 10 Feb 2009)

I've read a number of books on programming methodology lately - it's a good way to get ideas of how I could be doing things, and it's easier than working - and this is one of the better ones. Most such books have either good practical advice smothered under a layer of dogma - the advice may be good, but it's all got to be separated from the cant and jargon, and weighed individually. Others are good and thoughtful books without a lot of dogma, and also without a lot of practical application. These can be very thought-provoking, and often help you understand the work of producing code, or of working in a team to produce code, or of managing a team to produce code, but they don't give you anything as concrete as "use version control and unit tests, and here's why". Hunt and Thomas don't come off as defending an agenda, instead their advice is defended as both rational and experienced-based - a combination that's hard to beat. The writing is even pretty readable, which is rare in this realm.

One inaccuracy deserves to be noted: The authors' citation of experimental validation of the "broken windows" theory seems to be based on a folkloric retelling of the old Phil Zimbardo experiment - Zimbardo's account of this experiment is in The Lucifer Effect, and it's somewhat different from Hunt and Thomas's version.
Just so you know... ( )

One of the first books I read when getting more seriously into coding. First read was a bit over my head, but I grasped some of the concepts. After reading other books and doing more work, the next read a few months later was clearer and I found myself nodding more often. I think it's a book I'll keep returning to as long as I'm programming. Some of the tips it has apply to other aspects of work (and life), not just coding. ( )

Excellent book -- provides suggestions and guidance. You will need to apply some thought and sense to apply ( )

This book turned me into a professional programmer. Of course I had to work at it, but this book showed me the way. So I owe it a great debt. Like Extreme Programming, none of the techniques are new, they just work very well together. The book is short, some of the tips are strange (tracer bullets?), but most are exquisite, like Broken Windows (an abandoned house will be quickly vandalised if one broken window is not fixed immediately). Often compared to McConnell's [Code Complete], but this book is much broader, and barely touches on actual code or languages. The authors do prefer more dynamic languages, which is why they are now the Ruby champions, but they recognise that most programmers use more mainstream languages.

I still follow much of their advice, like investing in my knowledge portfolio, taking time to learn New Stuff. The month I spent learning FORTH is chalked up to experience, and I will probably never get to use my inside knowledge of the Z39.50 protocol (which is how Library Thing talks to library catalogues worldwide), but I tried Python and I now use it every day. Some investments pay big dividends!

Thank you, Pragmatic Programmers! ( )

Straight from the programming trenches, The Pragmatic Programmer: From Journeyman to Master cuts through the increasing specialization and technicalities of modern software development to examine the core process--taking a requirement and producing working, maintainable code that delights its users. It covers topics ranging from personal responsibility and career development to architectural techniques for keeping your code flexible, easy to adapt, and reuse.

The Pragmatic Programmer is a language and technology agnostic look at the craft of production programming. It covers all of the things you don't find in the typical technology specific book: How to write flexibly, maintainable code, source management, basic architectural techniques, career management. Basically, the stuff you need to know to be a successful "master" programmer. In some sense, if this book appeals to you, it's too late. You probably do a lot of what's contained in the book. It's still a fun and fast read though and you may pickup a few things here or there. This book is really aimed at the new professional programmer, maybe right out of college or with only a few years of experience. A lot of these guys won't be looking for a book like this, so it's up to us, the veterans, to point the way. As I said, it's mostly review for successful programmers, but it's still worthwhile to review the basics from time to time to make sure we don't stray from the path. The book is almost devoid of code, and that's OK. There are problems and exercises at the end of each of the brief chapters and there is a pull out card of the "pragmatic tips". Frankly, I find it hard enough to find time to read even an "easy" book like this, I just don't have time to work through the problems. However, I think this would make an excellent textbook for a course on the programming craft. This isn't something that is much offered at universities. They tend to focus either on vocational training (specific languages and techniques) or theoretical computer science. Almost no one I have hired out of college has the slightest idea of practical debugging techniques, source code management, team practices, etc. This book would be invaluable to them. Now, I would like to say a bit about the production of the book and the publisher. They self-publish. Yet, it's not a cheesy, vanity, print-on-demand type of thing. It's a real publishing house. But it's run by technically literate people and they produce books like it's software. That means a fast turnaround time, faster editing and quicker to market. Their theory is the faster they can produce the book the longer it will be a valuable resource. For those with the urge to write, they also offer a 50% post-cost royalty (versus the industry standard 10%). They really do print the books and they distribute them through a deal with O'Rielly, so you can find them in Borders, Barnes and Nobles, etc. But, you can also buy them direct off their website in either PDF or print or both. That's really cool. Bookshelf space being what it is, you rarely seem to have the book you want handy. It's either at home and you are at work or something like that. Even if it is to hand, it's often that it would be a heck of a lot faster to search the electronic version than thumb through the book (especially if you are like me and are easily distracted and end up reading or reading other stuff while you are there). Also, the PDF has no DRM, so you can print it out as well. For the record, I bought the printed version somewhere (I would guess Amazon, but maybe Borders). ( )