What a fantastic book.
U don’t have to be a programmer to read this book. It is a beautiful, well rounded, logically written book. Its tips, are things u already know, packaged in a way that u won’t forget!

Today is the age of pragmatic programmers not programmers. What it takes to turn a programmer into a pragmatic programmer is subtly described in this book. Although it is primarily intended to be read by programmers, what I found down the line was an invaluable set of insights for life alongside programming. It's not even an overestimation to say at some points the psychological side of this book takes precedence over its programming side. We're primarily programmers of our lives, so generalizing correspondent terms to both life and programming is not surprising.
Pragmatic programming stems from a philosophy of pragmatic thinking.
Setting the priority on the philosophy of pragmatic programming, the author sets the tone for an interesting voyage through the principles of pragmatic programming.

Taking responsibility is the first steppingstone in this voyage. When you take a responsibility for performing a task and its outcome, you're held accountable for it. So take the responsibility. You can find valuable insights all over the book and it sounds impossible to share all of them in a single review.

Then the book takes a pragmatic approach by defining a set of important terms like Duplication, Orthogonality, Reversibility and etc which are described in detail as steppingstones to set the big picture(the software) always strong.

While coding: There are worthwhile steps to take along coding which are subtly presented in this book. Here are some:
Programming by coincidence: The overconfidence generated under programming by coincidence spells a dangerous point. It's analogous to our own set of behaviors. There's an overconfidence generated under cognitive ease, which spells a danger point in our judgments, programming by coincidence also takes the same process. The remedy is in a consistent effort to understand the exact procedure and process of each part of code.

Refactoring:Refactor Early, Refactor Often
Refactoring takes courage even in programming. It takes courage to return and claim some of your overrated assumptions and change paradigms , but the supremacy of refactoring shows its role in long term. Clearly, refactoring is an activity that needs to be undertaken slowly,
deliberately, and carefully. Since you're setting up new structures, you have to consider refactoring a serious thing.

There are also some valuable insights to take before the project and in pragmatic projects.
Overall there is an analogy to draw among pragmatic teams and projects.
They comprise an interdependent set of independent parts. Each part is independent in its core and overall these independent parts are interdependent to set a stronger process.

One of the must read book for software engineers regardless which technologies you are working on.

A great non technical book that goes into codifying the good practices about software development. It is a must read for neophytes in software industry with a couple of years of experience.
If you have worked or are working in a good team and good project, you can easily relate back and forth about the goof things that are talked about.

It is simple to read, still relevant in 2016 and is worth investing couple of weeks to read this if you are aspiring to be a pragmatic programmer.

Despite how much I enjoy programming, I didn't enjoy reading about it quite as much >_< The authors advocated solid best practices, but I kept remembering work situations where those were forsaken for (arguably) practical reasons, and that was anxiety-inducing for me.

For a total beginner, the concepts will be difficult to internalize. For a seasoned programmer (on a good team...), it will be little more than a general reinforcement. While it's hard to imagine the right time in one's career to read the The Pragmatic Programmer (probably, often), it's a classic. It's written at a high enough level that very little material is outdated. In fact, some of the arguments ring much truer now than they would have in 1999.

See this review and others on my blog

Working with code in some way? Read this book.

In fact, it's a good book... if you're just beginning to program. I've just read it late, so it contains nothing new to me. I can't imagine that there are software developers who don't know about practices described in this book. Besides, it's already outdated (RCS? Really?).

As to Russian edition of this book, it's translated very badly, it's almost unreadable.

More like 3½ stars. I mean, not a bad book at all, and I'd probably recommend this to a young graduate getting started in the field of professional software development for LOB (Line of Business) applications, or someone who's been working for a while and feels like getting stuck, e.g. not making much progress. There's some solid advice from the authors who have 30+ years of experience in developing software, and I agree with most of it, though I find most of it unoriginal (still, curating and compiling experience, when done well, is a worthwhile effort).

The thing is, the book is a mix of many sub-fields of software development and doesn't go into much depth. More a like a limited and lightweight survey. Of course, if you haven't yet come across techniques and concepts such as property-based testing, FSM (Finite-State Machines), BDD (Behavior Driven Development, Cucumber, etc.), DSLs (Domain Specific Language), Reactive Manifesto, Functional Programming, challenges of concurrent programming, etc. those parts of the book can be an eye opener, provided that you venture into more in-depth research about these.

Another weird thing they do: jumping from one language to another for very short code snippets, e.g. using Ruby, Elixir, Rust, JavaScript... I can understand the reasons behind this approach, but still it presents somewhat ad hoc view, making it difficult to form a more unified view.

As I said in the first paragraph, I can recommend this to software developers just getting started, or people who think they're stuck in a limited domain / set of technologies + ways of working and want to see if there are better ways. On the other hand, if you've worked in a modern and intensive software technology environment for more than a few years, building complex applications and data solutions, and if you've followed ongoing trends even minimally, you'll most probably be familiar with most of the stuff in this book.

It's 20 years old book that can still give you good insights.

Highly recommended for beginners.

Pragmatic as the title suggests! Pleasant writing style and very useful.

Yüzeysel olarak baktığımızda kitaptaki örnek olarak verilen bazı araçlar ve diller artık eski güncelliğini koruyamamış olsa da felsefi açıdan bakınca prensipler, değerler ve kurallar halen geçerliliğini koruyor. Bu durum yakın zamanda okuduğum ve benzer şekilde yıllar önce yazışmış bir çok kült kitapla da paralellik gösteriyor.

Yine bir başka benzerlik de buradaki prensiplerin çoğunu biliyor olmamız ama bunlar kitabın kalitesini düşüren konular değil tam tersine niye zamanında okumamışım dememe neden olan konular olarak ön plana çıkıyor.

Yazılım geliştiriyorsanız mümkün olduğunca erken okumanız gereken kitaplar listesinin başına gönül rahatlığı ile koyabilirsiniz.