Reading List

We’d like to share the reading list for Orange & Bronze Software Labs' newly hired developers. We use this as part of our onboarding program alongside lectures, discussions, and machine problems.

We believe that this is useful either for a developer’s personal technical growth or for any organization's learning programs. More importantly, this is especially valuable for university faculty in Computer Science and Information Technology. We hope that professors would consider incorporating these books into their teaching, so that students graduating from CS and IT are better prepared to create robust, maintainable software from the very beginning of their careers.

Prerequisites: Prerequisites to this reading list are competence in the Java language and at least a conceptual understanding of Object-Oriented Programming. Before diving into these books, one should have at least been able to create an entire working system in Java - with GUI, data storage and business rules - as well as an understanding of the OOP concepts of abstraction, encapsulation, inheritance and polymorphism.

Effective Java, 2nd edition
by Joshua Bloch 

Clean Code
by Robert Martin
       

Frankly, the code that most fresh graduates write is messy. First of all, they write unmaintainable code. Second, they don't understand how the use of certain classes and methods affect performance. Third, sometimes the code they write doesn't even behave properly (ex: using float/double instead of BigDecimal, or code in a concurrent environment). Experienced developers usually have better coding practices but there are usually holes in their practices as well.

We usually start new developers off with these two books. Both are collections of coding practices, dealing with such topics as formatting, to "gotchas" in the Java language and API, to performance and concurrency. Robert Martin's book also starts to introduce the reader to Agile Software Development.

One caveat: Effective Java recommends the use static factory methods, singletons and the "final" keyword. However, these practices can come into conflict with some of the most popular frameworks for IoC, persistence and mocking such as Spring, Hibernate and Mockito. It's best to avoid those practices when working with these frameworks.

Refactoring to Patterns 
by Joshua Kerievsky

It's too early to introduce Design Patterns in the first weeks of our training course, but Chapter 4 of this book is good for its discussion on "Code Smells". Code smells are signs that there might be something wrong with the code, and part of O&B's developer training is to learn to identify bad code.

Design Patterns are taken up much later. For fresh graduates, we usually have them work on some real projects before training them in Design Patterns. For that training, we have them read "Head First Design Patterns" followed by the other chapters of this book.
It's too early to introduce Design Patterns in the first weeks of our training course, but Chapter 4 of this book is good for its discussion on "Code Smells". Code smells are signs that there might be something wrong with the code, and part of O&B's developer training is to learn to identify bad code.

Design Patterns are taken up much later. For fresh graduates, we usually have them work on some real projects before training them in Design Patterns. For that training, we have them read "Head First Design Patterns" followed by the other chapters of this book.
It's too early to introduce Design Patterns in the first weeks of our training course, but Chapter 4 of this book is good for its discussion on "Code Smells". Code smells are signs that there might be something wrong with the code, and part of O&B's developer training is to learn to identify bad code.

Design Patterns are taken up much later. For fresh graduates, we usually have them work on some real projects before training them in Design Patterns. For that training, we have them read "Head First Design Patterns" followed by the other chapters of this book.

Test Driven 
by Lasse Koskela

"Test-Driven Development" (TDD) is not about testing. It is about defining the expected behavior of code through executable tests. Think of it as specification documents that are executable. Unlike traditional specifications, TDD can verify if the code is complying with the specifications. TDD is therefore an essential component of a disciplined software development process.

Our training program covers the first four chapters of the book, which introduces TDD and Refactoring using a ton of code examples.

The rest of the book is excellent as well, covering such topics as TDD with web components, TDD with data access, TDD for time-based and multithreaded code, and Acceptance TDD. We recommend though that these chapters be read by developers after practicing TDD in real projects and getting the hang of it.

UML for Java Programmers
by Robert Martin

This is much more than a book on UML. This is another Robert Martin treatise on Object-Oriented Design and Agile Software Development.

It starts with answering the question, "Why Model?", where he begins to discuss the Agile perspective on visual modeling. In Agile, the goal of modeling is not to create comprehensive blueprints of a system, but rather simply to communicate design ideas between members of a project team. UML is therefore used more for sketching rather than formal engineering drawings. Bob Martin then goes on to discuss the rudiments of the three most useful types of UML diagrams - Class Diagrams, Sequence Diagrams and Use Case Diagrams.

Uncle Bob then discusses his "SOLID" principles of Single-Responsibility, Open-Close, Liskov Substitution, Interface Segregation and Dependency Injection. He ends the book with a couple of project examples including a real project he worked on.

Domain-Driven Design Quickly
by Eric Evans

   

Domain-Driven Design is the design philosophy where at the primary focus of a project is the embodiment of the business domain as the core module of the system. This practice not only promotes maintainability of the components that handle business logic, but also drives developers to strive to understand the domain very well. This in turn fosters collaboration between developers and domain experts.

For our training program, developers are only required to read "Domain Driven Design Quickly", which is the abridged version of Eric Evans' respected tome, but the full version is also available in our library in case anyone wants to do a deeper dive.

One thing lacking in these books are code examples. Thankfully, someone created a sample app.

The Agile Samurai 
by Jonathan Rasmusson

A fun introduction to Agile Software Development. It takes a light and often humorous tone, with lots of illustrations to help people remember the concepts. It covers the breadth of Agile - its rationale and values, planning, requirements, iterative delivery, communication, physical workspace and the engineering aspects of Agile.

Pragmatic Guide to Git 
by Travis Swicegood 

Maven the Definitive Guide
by Jason Van Zyl

 

Git and Maven are two of the tools we use in our projects. Git is a distributed version control system created by Linus Torvalds. Maven is a build and project lifecycle tool.

Head First Servlets & JSP, 2nd edition
Bryan Basham, Kathy Sierra, and Bert Bates

Good coverage not only of the Servlets and JSP but also of JSTL and the MVC Pattern. 

Even if our developers work with web frameworks in their projects, it's good for them to know what's going on under the hood.

Head First Design Patterns
by Eric T Freeman, Elisabeth Robson, Bert Bates, and Kathy Sierra 

Patterns of Enterprise Application Architecture 
by Martin Fowler

B

Design Patterns are solutions to common problems. Head First Design Patterns covers basic patterns such as Template Method, Strategy, and State. I usually have developers read the rest of "Refactoring to Patterns" in conjunction with Head First Design Patterns. Head First provides good introductions to the patterns, while Refactoring to Patterns provides a lot of code example of how to move from problematic code to the design patterns. 

Patterns of Enterprise Application Architecture catalogs higher-level architectural patterns found in enterprise applications. Examples include Domain Model, Service Layer and Model View Controller.

 JavaScript: The Good Parts
by Douglas Crockford

Ah, JavaScript...countless times have we heard Java developers curse this language. Yet, there's no getting away from it - it's now overwhelmingly the de facto standard scripting language for the client-side. 

JavaScript is an ugly language because it was rushed to release before it was ready. However, there parts of JavaScript that are actually quite powerful and expressive. This book is about those parts. Writing robust, maintainable JavaScript is actually possible. 

We're also heavy users of jQuery and we have "jQuery in Action" and "The jQuery Cookbook" in our bookshelves. There's also some interest in CoffeeScript.