Quite often experienced folks joining ThoughtWorks have a common set of questions: What should I read to prepare myself for ThoughtWorks? What kind of technologies does ThoughtWorks work on? Will I go on a Ruby or Java or Mobile project?
I doubt there is any good and precise answer to these questions. But, there certainly are some practices that I feel our in the DNA of ThoughtWorks. Agile & Extreme Programming practices drive most of this. Unfortunately, Agile means totally different things to different people outside ThoughtWorks. And, quite often, nothing will prepare you for the radical changes that are going to come to your way of working at ThoughtWorks.
So, I thought, why not try come up with some recommended readings for Dev Lateral hires (experience range of 3 - 10 years), to introduce them to some of our development practices, coding styles, unit testing beliefs, etc. I asked a few of my colleagues - namely Unmesh, Chirag, Sunit and Aman on what they felt should be the minimum recommended reading list for Lateral ThoughtWorkers. This is what we all came up with.
I may have used my discretion to sanitize the final list, therefore if you don't like the list -- blame me! :)
Highly Recommended Book ReadingRefactoring, Improving the Design of Existing Code (Martin Fowler)
This book introduces you to refactoring, code smells and patterns to help you refactor your code into something much more readable, maintainable and extensible. If you are new to refactoring, this will be an eye-opener. Note that examples in this book are targeted towards Java developers, but core concepts are valid in almost any serious programming language. Couple this reading with IntelliJ Refactoring shortcuts to realize how easy it is to perform useful re-factorings by Java programmers. At ThoughtWorks, the most popular Java IDE is IntelliJ. Its refactoring capabilities are beautiful.
Test Driven Development (TDD) By Example (Kent Beck)
TDD - A fundamental practice that has been very highly suggested by proponents of Extreme Programming (XP). This book (again in Java) helps developers in understanding how to think Test-First, and how unit testing affects the design and development of your code. It is a simple, tiny and very nicely written book that gets-to-the-point. Warning: You are not supposed to "read" the book, but follow it as-if Kent Beck himself is pairing with you. If you do not code along with this book, you may as well not read this book. If you are joining ThoughtWorks, you will benefit tremendously by understanding TDD.
Extreme Programming Explained (Kent Beck)
An excellent introduction to the values and practices of Extreme Programming, and our preferred flavour of Agile. It will give you an insight into how we work, and why we do things the way we do. A must read -- whether you are a developer, QA, BA, PM or any technically connected person who is joining ThoughtWorks. The book is deceptively simple. Understanding this book will explain to you the meaning of "being" Agile, versus "doing" Agile.
Clean Code: A Handbook of Agile Software Craftsmanship (Robert C Martin a.k.a Uncle Bob)
Coding is our bread and butter. Well, we prefer it nice and clean! Clean Code is taken very seriously at ThoughtWorks, and the techniques, tips and recommendations mentioned in this book are invaluable. This book is packed with code examples (in Java), and isn't something you read over a plane journey, but something you couple with an IDE, coffee and a leave-me-alone-to-do-as-I-please environment.
Other Recommended Book ReadingEven though I have mentioned the highly recommended ones, there are still some other books, that I just had to let people know they should consider reading. Each of these books are as much a gem as the ones above, except that if you think like an economist, who wishes to maximise his returns at ThoughtWorks, then maybe you will start with the list above, and later digest the ones in this section.
The Pragmatic Programmer: From Journeyman to Master (Andrew Hunt, David Thomas)
A collection of very practical & solid advice on many many aspects of Software Development. Reading this book will make you feel you are being handed out information and knowledge developed by the authors through years of hard labour, failures, learnings and successes. Quite a collection!
Agile Software Development, Principles, Patterns and Practices (Robert C Martin a.k.a Uncle Bob)
Uncle Bob introduces Agile practices, and shows how teams need to design and develop code so that Agility can be attained. Even if you didn't work in a team that followed the Agile methodology, you definitely need to know these design principles. Most of them are fundamental to how good software should be created.
Effective Java [2nd Edition] (Joshua Bloch)
If you are a Java programmer, then you have to read this book. This book is filled with pearls of wisdom on how to use the Java programming language way more effectively than you thought possible. I still pick it up this book time to time, to refresh my Java knowledge. Please read it.
Continuous Delivery: Reliable Software Releases Through Build, Test and Deployment Automation (Jez Humble, David Farley)
How does one make software delivery and releases -- painless and a non-event. What processes, practices and tools should teams follow so that one-click delivery is possible. Turns out, it isn't so easy - but then it isn't rocket science either. All ThoughtWorks projects aim towards providing Continuous Delivery, and this book will give an insight into our methods of achieving those.
Implementation Patterns (Kent Beck)
Kent Beck takes the sum total of all his experience in programming, Smalltalk & Java, and categorizes it into a set of Values, Principles and Patterns (with lots of good examples) for us to realize. This book will make you a much better programmer -- one that others will be able to appreciate.
Recommended Reference Links on the Internet
There is a wealth of information on the Internet, undoubtedly. Although I do feel that books seem to deliver a more "complete" experience and understanding -- since they take you through a complete story line with a full narrative and total context. The articles on the internet seem to provide a window to possibilities - and there are few folks who publish the "complete picture". Although, the situation has been remarkably improving in the last two or three years. One has to be very judicious and thorough when reading / learning stuff on the internet. As a reference guide - the internet is priceless. There are always exceptions to the rule. Always.
Some recommended reference links on the internet that will help the new ThoughtWorker:
- Uncle Bob: Principles of OOD
- Refactoring Catalog
- Martin Fowler's Blogs
- ThoughtWorks is Roy's Social Experiment
- The New Methodology
- Patterns for Daily Standup Meetings
- Continuous Integration
- Mocks aren't Stubs
- Ruby At ThoughtWorks
- Is Design Dead?
- xUnit Patterns
- Systems We Make
- What should every programmer know about Web Development?
- A baseline for Front-End Developers
I would use these links as a starting point, or a seed, to lead me into further research, based on what I find interesting and parts where I feel I need a better understanding.
Welcome to ThoughtWorks!