A must-read for all programmers irrespective of how experienced one is! The book does a very good job of taking us through the most important aspects to be a good programmer.

Overall, good as a refresher of what has become common sense among more experienced and disciplined developers, with a valuable principle here and there.

While many complain about already knowing everything in the book, or that it's outdated, I believe they are quite missing the point. Perhaps this book didn't speak to you at the point you are at in developing your skills and crafts, but it might speak to someone else just beginning. Rating the book low for the reason it wasn't what you needed is rather disingenuous, as a rating should be a guide to the quality of the book overall.

The information contained in this book is essential for software developers who want to develop their skills and knowledge into a craft worthy of renown, to become masters of the field. It is essential for anyone working in a team or working solo.

The book is dated in the specific examples it uses, as would any book become so dated. What is *not* dated are the principles, the tips, the stories, the **wisdom** of this book.

As I was reading it, it felt all so familiar. Yes, most anyone who has been at the craft of software development will probably recognize much of this. I felt like the authors had been following me around during my consulting practice in the 90s as they pull from the same stories, lore and practice that I taught. Reading this book now, in 2012, I recognize all this and am grateful for the review. One may know a lot of practices, but having a refresher on the extent of what matters in software development helps.

As I approach a new team, a new job, I am looking to convey a lot of these concepts to people who may have only been cursorily exposed to them, and develop the team into a high quality, high craftsmanship group. This book will aid in that quite a bit, I hope (although the Russian translation may be lacking).

If you are just starting out, read this book.

If you are in the midst of your career, read this book.

If you are an experience veteran of the craft, or feel yourself a master, read this book, THEN TEACH IT.

O culegere de sfaturi și idei pentru programatori pragmatici, răsărite din zeci de ani de experiență. De asemenea, sfârșitul capitolelor conțin câteva exerciții (cu posibile răspunsuri) și provocări, pe care eu însă nu le-am sărit deocamdată.

În mare parte, mi-au plăcut ideile oferite de autori, precum:
•tconceptul ferestrei sparte, care pare a fi evenimentul comun care declanșează ruina clădirilor în bună stare; similar, precum codul care nu e ”clean” declanșează ruina programelor
•tsă admiți mereu când nu știi ceva, dar să îți asumi responsibilitatea să afli
•tsă îți menții atenția și asupra lucrurilor care se întâmplă în jur, nu numai asupra celor la care lucrezi
•tsă livrezi des pentru a putea avea feedback constant de la utilizatori
•tsă încerci să înțelegi necesitățile utilizatorilor atunci când aceștia solicită funcționalități noi
•tsă îți creezi o obișnuință din a investi în portofoliul propriu de cunoștințe (similar celor care investesc în portofolii financiare), învățând limbaje și lucruri noi, chiar și în afara orelor de serviciu, pentru a te menține mereu la curent. Diversificarea este cheia succesului pe termen lung
•tsă înveți un limbaj de programare nou în fiecare an, căci procesul de a învăța duce la modalități noi de a gândi, iar polenizarea ideilor este importantă
•tsă încerci mereu să creezi cod care e ușor de schimbat
•tsă ascunzi serviciile externe în spatele unor abstracții (e.g. interfețe)
•ta crea un prototip este o experiență de descoperire și este în esență o activitate a cărui scop este a învăța. Codul produs trebuie aruncat ulterior la coșul de gunoi, iar cei din jur trebuie să fie conștienți de asta
•tsă încerci provocarea de a lucra o săptămână fără mouse, ci numai cu tastatura, pentru a descoperi limitele acțiunilor pe care le poți face numai cu tastatura și pentru a-ți îmbunătăți ulterior productivitatea

De asemenea, au vorbit și despre nenumărate concepte de programare și pericolele sau beneficiile acestora, precum mixins, configurații, paralelism, dependențe temporale (din engleză, ”temporal coupling”), ”shared state” și ”mutable data”, testare, documentarea codului, optimizare prematură, securitate, denumiri, și altele asemenea. Aici opiniile lor sunt, în general, aliniate cu ideile agile și de ”clean code” ale altor autori, precum Robert C. Martin, Martin Fowler etc.

O anologie nouă, pe care am descoperit-o în această carte și care mi-a plăcut destul de mult, este că programarea se aseamănă cel mai mult cu grădinăritul: codul este maleabil și organic și trebuie plivit în mod constant pentru a evita ca buruienile să distrugă totul în mod ireparabil.

Review for the 20th anniversary edition, audiobook format:

This is a well known book, full of practical advice for programmers, now updated after 20 years with new examples, and some newer advice that aligns with the current times. Still the core of the book remains unchanged.

Who do I recommend this book to: Software engineers starting out in their careers

What works and doesn't work in audio format:
The audio production is top notch. I like the book narrator and occasional stories narrated by the authors. The code samples don't translate well into audio.

Seminal book for programmers - but the 20th edition is a superior read! They done an excellent job of bringing it into the modern programming era.

Good information for software developers / engineers. Very similar to Uncle Bob's books (Clean Coder, Clean Agile, etc). Teaches you how to think like an effective developer.

I enjoyed the pragmatic programmer.

Still I found myself skipping sections, especially where I felt the subjects discussed I already had a good grip on. Other parts just felt dated, like the sections on source control and "modular code" in the age of distributed git, npm and microservices.

I would definitely recommend this to programmers looking to up their game. The advice this book gives for you to become a better programmer is solid, and you'll find yourself agreeing with it. You should especially pay attention to the more general software design aspects the book discusses. Just don't get caught up trying to implement every single hardcore system engineering principle the book highlights.

When I started my IT learning journey almost a year ago, this book constantly popped up as the recommended first read to all programmers, no matter their level. Because I was so overwhelmed with all new coding "things", like definitions, principles, syntaxes and good practices, I simply avoided a new headache of responsibly researching what should come into my "future IT reading list" and just took this "mainstream must-to-read". I. e. "The Pragmatic Programmer".

Admittedly, I wasn't hoping much from it. Most of all, I was anxious that my low-level understanding of this field will make it impossible for me to read and understand all that gibberish stuff in the book :) Yes, I haven't understood many things but I understood many others!

"The Pragmatic Programmer" is very comprehensive and it gives a broad view of the industry and touches on many different aspects of the path chosen by programmers. It's not strictly technical, the book talks about general principles and patterns of how to approach technical aspects/ problem solving, about many "soft" aspects of this field, and gives many tips on how to enhance your performance.

Many things were new for me and I faced them for the first time ever in my life but I said to myself that that is fine. Now I get 10-15%, the next time when I will be reading it will reach 30%. Early on I decided that this book is one for re-reading because it should award readers with different things at different stages of their "technical" growth. For now, it helped me to understand the scope of this field and shaped my mindset on how things should be done by pragmatic programmers. The next time I'll understand technical aspects better and somewhat in the future, I believe, this book will be helping me to become a highly professional software developer :P ... Oh, it seems, that escalated quickly :D

In any case, "The Pragmatic Programmer" covers many topics and proposes a guiding hand while navigating this binary jungle. It doesn't dive that deep into every topic but it shows you what you should know. And the rest of the digging is on you ;)

So, yeah, if you are interested in the IT industry and you also would like to become a software developer, it is a really helpful text. You will go through all phases of software development, including working with people and understanding clients.

This is my favorite non-technical tech book. It explores good software development practices. In my opinion it is more than just a checklist of what you should do - it literally changed my approach to development with positive results.

Others have mentionned that they already knew most of the things in this book, and practice these good habits in their development environments. I've worked in dozens of environments ranging from very successful experienced companies, to fly-by-night operations that have no business writing code. Any one of these environments would have been vastly improved if some of these practices were incorporated. (And in several environments, I was able to introduce some of these concepts which led to increases in productivity and happiness)

If you and your organization already does everything in this book, and you see it as a "ho-hum" read, congratulations to you. For the rest of us, I think this is chocked full of high-level abstract concepts that will improve any development environment. It's communicated in a very straight-forward manner, and also advises you to take a pragmatic approach to everything - only using the things that make sense in your situation.

Overall, a wonderful book.

Originally posted here: https://erkinunlu.net/books/pragmatic...

8 out of 10 this time around.

I read the original book around 8-9 years ago. To be honest, it probably defined the engineer I am now, back then. I was kind of devastated with my first two professional experiences back in Turkey where there were either no engineering practices at all or if any, done poorly. So in the absence of a better example, this book is one of those books that I used to teach myself what software development profession must be like. The insights I got were definitely invaluable. For the 20th Anniversary Edition, Dave and Andy more or less rewrote all of the book and added some complete new sections to it (really good for my money). I still enjoyed the book a lot but this time I've seen some parts of that are a bit off to me which I highlight below. "**The Basic Tools**" section is still essential to all levels of software developers (with some minor exceptions).

## The good

- First of all, a confession: book starts its argument that as software developers we are responsible for our work and we should care about it, question it, and explore better ways of doing it all the time. This is a good wake up call to a cynical software engineer like me : ).
- The major benefit I got back then and also this time around is the concept of Tracer Bullets. Even though it's a military term, this concepts explains the importance of implementing a thin layer for the final application in an end to end fashion, thereby unearthing most roadblocks that can happen along the way in one go and gives the team a solid footing in the start of the project and what may happen next.
- Another major concept is the infamous "No Broken Windows" theory applied to software projects. This theory has its origins from the last years of the crime surge in United States (has had much worse implications for the ordinary and poor people by the way). When applied to software projects, this idea suggests that quality throughout the whole project must be upheld all the time, meaning all code should be easier to change, no coupling, orthogonal modules. And this brings us to the next topic below:
- Book really emphasises the importance about **testing**. To this end, it even goes on and destroys one of its staple ideas: **Don't Repeat Yourself**. There are more than a handful of sections dedicated to testing.
- Andy and Dave neatly summarises what it means to be **Agile**. They reiterate the famous "interactions with people over processes" and others and explain in more detail. It's really nice to explain that "agile" is not about tools and documents etc, but how you do your work. More on this on the other side below though.
- Functional programming is explained much better in this version. Authors explain the notion in Transforming Programming section, liken the idea to pipes in terminals (which is of course spot on), which also decreases the coupling in the system. Not sharing the state, another benefit of FP is also discussed in detail.
- The book further delivers blows to Object Oriented Programming with its "Inheritance Tax" section. This is again an established notion which some people also call "Favour Composition over Inheritance". I hope that more people would come to the idea that OOP is not a silver bullet and should not be the first go of every software project out there.

## The bad

- At one point Dave confesses that he doesn't write tests anymore! He justifies this with the fact that he is now a master programmer therefore, he doesn't need to write the tests, he writes his code "testable" anyway, meaning that the software he produces is already loosely coupled and well though out with edge cases and contracts and so on.
- Even though I really like think that agile practices like estimations and user stories and others help with most of the corporate software we are building these days, authors should have asserted that some practices preached here is also not "One Size Fits All" ideas. This is still a minor point anyway.
- Furthermore, there's this nice concept of "Design by contract" which is a good precursor to Property Based Testing. But how to breach the gap between User Stories (which are vague statements basically) and "Contracts" (which is literally human language way of writing mathematical properties) is a bit left out. You might simply deduce from the fact that if you are Agile, you'd be talking to your user all the time, but I still think this constant communication with users is a waste of time for everyone involved.
- Despite the fact that (arguably) most of the audience of this book will be American readers, I found the tone a bit too American and prophet-like (of course you cannot compete with Bob Martin in this regard).
- There's just too much in the book. This makes it a bit hard to concentrate on what really matters (there are 53 topics inside the book!). I wished the authors would just pick up the core ideas and explain them in lengthier detail to make the point across better.

What an interesting book! Definitely a worthy read and for sure a book I will revisit in the future - mostly because I filled it with post-it notes.

Does this book provide some ground-breaking ezotheric knowledge regarding software development? 100% no.

It's a very... pragmatic book, oozing with arguments in favor of common sense practices which should be used in all projects, no matter the scale or purpose. It can also be quite funny at times. Some chapters are a bit stale - chapter 3 "The Basic Tools" and chapter 6 "While you are coding" were my least favorite and the main reason I haven't rated the book 5 stars. The first 2 chapters were really enjoyable and the last one "Before the project" is amazing.

All in all, I'm glad I picked up this book. I'll leave one of my favorite quotes here:

n  In an abstract sense, an application is successful if it correctly implements its specifications. Unfortunately, this pays only abstract bills.n