Archives: December 2004

Recommended reading list for Java Developers/Software Engineers (December 2004)

There are some books you come across that are destined to become all time classics, well worth reading and recommending to others. This is a list of books that I’ve read that I recommend all software developers must read. The list has a strong Java bias as afterall I’m a Java developer myself, but has a mix of both technical and non-technical.

For the past several years of my career I neglected to read project management/software development process type books (after I finished my Computing degree anyway), but there is so much to be learnt from others sucesses and mistakes, regardless of whether or not you intend to become a team lead or expect to find yourself in a less technical role. Afterall, writing the code is only part of the process; a good understanding in tried and true practices, theories and software development processes leads (in my opinion) to a much stronger, well-rounded developer.

As Steve Maguire points out in his book, Debugging the Development Process, why spend years of your career learning by trial and error when you can pick up a good book and learn from insights from others who have already ‘been there, done that’.

In no particular order, here’s my recommended book list:


The Mythical Man Month – Fred Brooks

Written over 20 years ago, this book is a collection of essays on typical problems encountered on software development projects, and what is scarey is that the same problems still happen today. Although some of the examples refer to IBM mainframe development, the lessons learnt still apply to software development today.

Design Patterns – Gamma et al (GOF – Gang of Four)

The Bible of Design Patterns. Why reinvent the wheel when there is already a solution/approach to a commonly occurring problem?

Refactoring – Martin Fowler

Encourages continual review of exising code and during actual development to identify areas for improvement. Identifies typical problem areas (‘smells’..!) that occur in code, and suggests solutions for reworking code to become cleaner, easier to read and maintain.

This is one book I’ve known about for a while but never had time to sit down and read from cover to cover, and wish I had done much earlier…

UML Distilled – Martin Fowler

If you’re going to read one book on using UML notation for analysis and design then make it this one. Short and to the point, covers the main aspects of ech of the diagram types and notation to get you started.

Thinking in Java – Bruce Eckel

This is the best written and most comprehensive book on Java and it’s language features that I have read so far. It goes into far much more detail explaining concepts and the rationale for language features that I have come across anywhere else. If you are just starting out with Java, or even if you’ve beeen developing with Java for years, this is an excellent book

Java in a Nutshell – David Flanagan

This was one of my most referenced books when I first started out as a Java developer, and there were several very well-worn copies in the office at one time. As a reference it really is no more than the API in book form, which is great if you’d rather flick through pages than read API info on the screen. Also more useful is the very short and condensed introductory chapters which give a very quick highlevel intro to Java and most of the language’s core features. This is a great reference for language specific features like operator precedence and ranges of the primitive data types, info that is not too easily accessible elsewhere.

This book doesn’t seem to be as popular as it was a few years back, and most new developers nowdays have not come across this book. I suspect this book was more useful when the core API was smaller, but now Java encompasses so many areas there is no longer a single source of info you can go to, you need other books on more specific areas that you are working in (J2EE features etc)?

Mastering Enterprise Java Beans – Ed Roman

For learning EJBs, this is a very well written book. The examples are somewhat lengthy, but I think this is a very good bok. Again, covers more background info than most (transaction support, isolation levels, best practices etc).

Effective Java – Joshua Bloch
For more advanced Java developers looking to broaden their knowledge of using the language, this book is a series of tips for how to more effectively use the Java language for commonly encountered scenarios. This is one book I refer back to often.

Bitter Java – Bruce Tate

I’m not sure if this was the first book to introduce the concept of the ‘Anti-Pattern’, but this book is a great collection of war stories and lessons to be learnt. This book collects together commonly made bad design decisions and inappropriate uses of Java technology, and then makes suggestions for how to more effectivly use Java to solve the problem. Again – why learn from your own mistakes by trial and error when you can learn from others who have already made the mistakes?

Debugging the Development Process – Steve Maguire

This is an older book (published 1994) and the author uses examples from his experiences working on projects at Microsoft, but still, there are some good lessons to be learnt from this book that are still applicable to any software development project. This book is an easy read and makes several key points that are valuable to both developers and team leads to become more effective and focused at achieving goals and delivering quality products.

Hibernate in Action – Gavin King and Christian Bauer

This is the bible of all things Hibernate. If you are looking to implement a persistence solution other than writing your own JDBC or using Entity Beans then Hibernate is a must. If you are considered Entity Beans or JDBC then you should be considering Hibernate instead. If you’re already using Hibernate then this is still a good book for explaining concepts and features that may be harder to grasp from just the online docs.

Hearding Cats – A Primer for Programmers who Lead Programmers – Rainwater

This is a useful read for developers finding their career path moving in the direction of team lead type roles. Not all technically minded people make good managers, just as good people-type managers do not make good technical managers. The think the key takeway from this book is to recognize the skills and strengths of your team and use those to more effectively acheive your teams goals.

I also have a must read list of books that I haven’t got to yet – some of these are already on my bookshelf but I just haven’t had time to read yet:

  • Code Complete – Steve McConnell
  • Professional Software Development – Steve McConnell
  • Extreme Programming Explained – Kent Beck
  • Expert One-on-One J2EE Development without EJB – Rod Johnson
  • Joel on Software – a collection of articles from his website joelonsoftware.com. I’ve read some his articles online on his general thoughts and experiences from being involved in software development – his website is a good read so this book should be worthwhile.

(Page views: 1)

In-memory Object database

This caught my eye as their performance stats compared to other traditional RDBMS are staggering.

Prevayler is an in-memory Object persistence mechanism as a direct replacement for a database. The in-memory representation of your objects is the database, so their is no need to query the objects to retrieve them. This also means you can navigate object graphs as you normally would, without using any complex query language.

So how does it keep data persistent? Apparently it serializes all your object out to disk periodically.

Incredibly simple, but I bet incredibly effective. If you don’t have a need for GB of relational data, the this seems like an ideal solution for small webapps etc.

(Page views: 4)

OnJava.com article on AOP based Remoting

OnJava.com have the first part of a series of articles on their site introducing Aspect Oriented Programming (AOP).

This first article is very short and simplistic and introduces how easy it can be to use AOP to mark up a POJO and have it run as a Session Bean at runtime on the App Server.

This article introduces AOP support in a framework I have not come across yet called Genesis – something else to add to my research list for my spare time.

I can’t help thinking though that this example looks very similar to the upcoming J2SE5.0 supported annotation which are going to be heavily used in EJB3.0. If I were going to start looking at this then I think it would be more worth my time starting to look at the EJB3.0 preview implementation by JBoss, which they have freely available on their site. According to their docs this is an almost complete implementation of the current EB3.0 draft spec, so this would be well worth looking at now to get up to speed before thie latest J2EE major change hits the streets in all the latest App Servers.

(Page views: 3)

Direct Web Remoting (DWR) project enables client/server type behavior from web pages

This is not a new concept as I have used this solution before at a previous company to mimic client/server type operation from the web page, but it’s interesting to see someone publishing an open source project to offer this behavior.

Direct Web Remoting works by including a non-visible frame in your webpage that is controllec via Javascript in your main page frame to submit and retrieve data from a Servlet. As the data is retreived the main page can update its content dynamically using Javascript. This gives the illusion of the page being able to dynamically update itself with data and content from the server without the page refreshing or submitting itself back to the server.

(Page views: 1)

Microsoft’s new file system, WinFS still years away

Microsoft are admitting that their original delivery plans for WinFS, the new Windows file system replacement, were too eager, and the new system may not be released until late 2006, but then only in a test version.

Longhornm, the next major Windows release, and Longhorn server, will not be shipping with WinFS.

WinFS is drawing a lot of press as it is intended to be a complete file system relacement built on top of a database, probably a new version of SQL Server, completely replacing the MS-DOS based file system that has been used with Windows for several years.

(Page views: 5)