Implementation patterns

What Hacker News says

1. KerrickMar 2025
   Read books. Like, a lot of them.

   Start with Make It Stick (Brown et al.). Apply what this book teaches you to every one afterwards.

   Next, read and work through Exercises for Programmers (Hogan) and A Common Sense Guide to Data Structures and Algorithms (Wengrow).

   After you finish those two, read The Missing README (Riccomini et al.) and Extreme Programming Explained (Beck et al.). These two books provide very different viewpoints into the stuff that isn’t coding in a programming job.

   Assuming you’re using an OO language, follow that up with Object-Oriented Analysis and Design with Applications (Booch et al.) and Object Thinking. They contrast each other quite a bit; having both perspectives is handy.

   Once you’re through all those, I recommend Tidy First (Beck), Implementation Patterns (Beck), and Test-Driven Development By Example (Beck). These three books of his provide an incredibly accessible view into better ways to code.

   If you’re anything like me you get bored reading one book for too long. I’ve found that having a second book going that I can switch to is great for that. A parallel track with The Pattern On the Stone (Hillis), The Pragmatic Programmer (Thomas & Hunt), The Mythical Man-Month (Brooks), and How Computers Really Work (Justice) provides a reprieve and some technical and cultural context.

   Show morethread
2. belfalasJan 2023
   Many more beyond this but these are my for sures.

   People / Soft Skills:

   * How to win friends and Influence People - Dale Carnegie

   * Secrets of Consulting - Gerald Weinberg

   * Peopleware - Tom DeMarco & Timothy Lister

   * Nurtured by Love - Shinici Suzuki

   * Turn the Ship Around! - David Marquet

   * Never Split the Difference - Chris Voss

   http://dhemery.com/articles/resistance_as_a_resource/

   http://dhemery.com/articles/managing_yourself_through_change...

   Macro Skills:

   * Toyota Production System - Taiichii Ohno

   * Workplace Management - Taiichii Ohno

   * Thinking in Systems - Donella Meadows

   * Fifth Discipline - Peter Senge

   Agile:

   * Extreme Programming, Explained (2nd ed.) - Kent Beck (the annotated bibliography is a goldmine)

   * Chaos: Making a New Science - James Gleick

   Programming:

   * Implementation Patterns - Kent Beck

   * Test-Driven Development, By Example - Kent Beck

   * Refactoring (both editions) - Martin Fowler

   * Refactoring to Patterns - Joshua Kerievsky

   * Practical Object Oriented Design - Sandi Metz

   * Functional Programming in Scala - Chiusano & Bjarnason

   * Growing Object-Oriented Software, Guided By Tests - Freeman & Pryce ("The Goose Book")

   * Modern Java in Action - Raoul-Gabriel Urma

   * Java Concurrency in Practice - Brian Goetz

   * Grokking Algorithms - Aditya Y. Bhargava

   Architecture:

   * Righting Software - Juval Lowy

   * Release It! - Michael Nygard

   * Site Reliability Engineering - Beyer, et al. ("The SRE Book”)

   * Domain Driven Design - Eric Evans

   * Introduction to Permaculture - Bill Mollison and Mia Slay

   * Fun with a Pencil - Andrew Loomis

   Design:

   * All books by Edward Tufte, especially “The visual display of quantitative information”

   * The Elements of Typographic Style - Robert Bringhurst

   * Understanding Comics - Scott McCloud

   * Design of Everyday Things - Don Norman

   * Notes on the Synthesis of Form - Christopher Alexander

   * The Timeless Way of Building - Christopher Alexander

   Show morethread
3. pjmorrisJun 2017
   'Implementation Patterns', Kent Beck. A semi-language-agnostic extension of his 'Smalltalk Patterns'for how to clearly and consistently express what you're saying when you code.

   'Facts and Fallacies of Software Engineering', Robert Glass. Glass presents a list of things everybody knows, or ought to know, and gives both academic and opinionated support and/or critique for why they are and aren't so.

   'Making Software', Oram and Wilson. An edited collection of papers on evidence-based software engineering.

   'The Deadline', Tom DeMarco. A thinly disguised commercial for his advice on how to organize software development teams and organizations, packaged as light, light novel.

   Show morethread
4. _m4Nov 2011
   I am a bit suprised to not see TDD or any of its siblings being pulled into the discussion.

   To me, the better someone is doing TD, the better the code communicates because TDD makes you think about the right things when coding. It sets your priorities straight.

   So the question of n00b or vet for me is just how well someone does TDD. And there is also this great book by Kent Beck about Implementation Patterns that is all about well-communication code.

   Show morethread
5. eneveuSep 2011
   I am passionate about writing good code, and I'll try to offer some practical advice. As others said, the first step is understanding the importance of writing clean code and taking pride in your craft. By doing this, you are already ahead of most other programmers who don't really care. Now, how do you improve?

   1) Read books.

   With 4-5 years of experience, you already have a good intuition for "good" and "bad" code. Still, it doesn't hurt to learn more about it. There are a lot of good books on this subject.

   The first is "Clean Code", by Robert C. Martin. It's the first book I read on this subject, and I learned a lot. Note that the book uses Java in the examples, but I think the ideas would apply to most other languages.

   Its author, Uncle Bob ( http://en.wikipedia.org/wiki/Robert_Cecil_Martin ) has long been a proponent of writing clean, beautiful code. He recently did an interview for Xebia: http://blog.xebia.fr/2011/05/25/interview-avec-robert-martin... (French blog, but the interview is in English). In it, he advises:

   "Well there are a number of books that talk about writing code well. Kent Beck wrote a book called “Implementation Patterns” very recently. It’s an excellent book all about software craftsmanship. The pragmatic programmers wrote a wonderful book in 2000 called “The pragmatic programmer”, again a wonderful book. Chad Fowler wrote a book call the “Passionate Programmer”. Again the book is about doing everything well. I wrote a book recently called “Clean Code” which is very specific about particular things you can do with your code to do it well. So there is a tremendous number of resources that are available for people who are interested in doing software craftsmanship well."

   Out of those, disregard "The passionate Programmer". It's an okay book, but its focus is on building a good programmer career, not on code.

   "Implementation Patterns" by Kent Beck is a great book with a lot of best practices when writing * Java * code. Less useful if you use another language.

   "The pragmatic programmer" is a good book on software craftsmanship. I'm personally half-way through. There is a lot of good advice in it, but I often find myself thinking it's "common-sense". Maybe because I've already been exposed to most of the ideas by reading blogs? Still, it's a great book, with a lot of best practices. It's main focus is not code, though, so you might want to start with other books if your focus is on writing good code.

   To these books, I'd add "Code Complete (2nd Edition)" (language-agnostic) and "Effective Java 2nd Edition" if you use Java.

   Summary:

   If you use Java, read:

     - Clean Code - http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
     - Effective Java 2nd Edition - http://www.amazon.com/Effective-Java-2nd-Joshua-Bloch/dp/0321356683
     - Implementation Patterns - http://www.amazon.com/Implementation-Patterns-Kent-Beck/dp/0321413091
     - Code Complete / Pragmatic Programmer
   

   If you use another language, read:

     - Clean Code - http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
     - Code Complete - http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
     - Pragmatic Programmer - http://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X
   

   Other people might chime in with suggestions for other languages?

   2) Practice.

   Implement what you learned in the books. Keep improving.

   3) Read other people's code.

   Read good open source code. Not all code is good code. Ask around for OSS projects with good code in your language.

   If you use Java, start with:

     - Google Guava - http://code.google.com/p/guava-libraries/
     - Google Guice - http://code.google.com/p/google-guice/
     - Spring Framework - http://www.springsource.org/
   

   4) Practice.

   5) Practice.

   Show morethread
6. emilamNov 2010
   I'm a big fan of IEEE Software magazine. http://www.computer.org/portal/web/software/home

   They have a lot of good authors who focus on different aspects of design and architecture.

   I also enjoyed Implementation Patterns by Kent Beck. It is not so much on the architecture of the system, but focuses on the implementation of classes and routines.

   thread