They are the best of what I know in terms of stunningness / time spent reading ratio. Here I will tell you about just serious stuff books, not even obvious and kindergarden ones like GOF Patterns or Refactoring. Everybody have read them already anyways. If not, rush to read them, they are the ABC. This article is not for newbie, it is rather for high level developer, who want to to become a really elite one. Books that I will list are really fundamental. Every one of them was a turning point in my head. The problem of many developers is shallow knowledge. They tend to operate technologies, not an ideas or concepts that sit behind. Normally in one technology there can be many concepts. E.g. in Spring the central concept is dependency injection, spiced with cross cutting concerns (AOP), it is using external, xml based DSLS, convention over configuration, etc. Dissecting any technology into subconcepts like this is crucial. Operating with concepts is much more powerful, it can be used to easily replace technologies, e.g. to use Guice for DI or Pico Container. Learning new technologies are also much easier if to know underlying concept. Another example. Hibernate as technology is an ORM (concept) and can be replaced with Toplink, Data Nucleus, JDO (technologies), wrapped with JPA, and so on. Some concepts are big, container ones, composed of other, many smaller sub concepts. Listed books are not new and somewhat classic, but still number one, since old relational model is still ruling the enterprise.
Patterns of Enterprise Application Architecture. Martin Fowler.
Overall Marting is one of the best authors in IT now. Although not all the ideas are his own, but he has really a talent to aggregate what is hot now, understand and describe for reader so that it is interesting
to read. Main thing here is deep understanding, which is surprisingly rear talent for most book writers.
He also writes from concept perspective, not technology. This book covers the very heart of enterprise:
domain model, ORM, transactions and many
other valuable things. You will quickly know why procedural approach aka "transaction script" is bad and objects aka "domain" are good.
Well, reading just this book will give you +100 points to enterprise wisdom easily. Most of Martin's books are worth reading. E.g. the latest DSL book is great. Some of his signature series books and blog are worth checking too.
2. DDD aka the big blue book, aka Domain-Driven Design from Eric Evans.
Great Author, the main his book. His voice
in Software Engineering Radio podcast is a bit drowsy, but to read his book was great experience for me.
Domain - the holy grail of enterprise. It is very hard to build, but it is very valuable. You will know how to do it not just in theory, but practically, with source code examples. I guarantee, you will never be the same again after this book. Also there is a free concise version of book
from InfoQ. Highly valuable patterns. They cover EJB, Spring, Hibernate areas conceptually. After the books 1 and 2 you
will not only know how to use technologies, you will know why they are needed and the rest derives from it.
Stay with me, do not faint yet.
3. Main TDD book. Guess who, Beck?, Buch?, Bloch?, Borat? No.
Of course gorgeous
Michael Feathers. The title is very misleading. I think to hide
this knowledge from aliens if they come :) It is
Working Effectively with Legacy Code. And the thing is, the code that you wrote, writing now, or will write today evening is already legacy. Why the best book about TDD? Because everybody knows all the dull obviousity, like
tests are good, write test then code, tests should be independent, and so on. Nobody can tell how actually
to write the toughest part, how to do it in real life, especially in existing system. And the toughest part is
how to cut dependencies. So in this book Michael shows 1000 and 1 way of how to cut dependencies. He has very
interesting vision of good design. It is good if it is testable, that is it. Very simple and pragmatic. So e.g. final class is bad. Surprised? Read the book.
As a bonus, some great techniques like Scratch Refactoring and Naked CRC.
After that I promise,
You will be the super TDD guy. Very effective. Also as somebody wrote in the web,
"Before learning DDD and TDD my programming was nothing but blind hacking" Very very true I must admit. So reading 2 and 3 you will get a super power. I invented a special name for it: T5D (TDD + DDD) Why TDD is ever mentioned in this list? You won't build reliable DDD without it. As simple as that. Also TDD is very useful on dull projects. You can entertain yourself by sticking
unit tests here and there.
4. So 1,2 covers the enterprise, what is left? SOA? joking, joking. Don't hit me hard, but to me SOA smells bad. First, nobody can explain what it is, because the term became too ambigous. Uhm is more concret word. And also it is coarse
grained interfaces and looks like old procedural approach, similar to remote EJB 2. To SOA I prefer the word integration. Really tough area.
Do not overuse it, do just if forced to. It is an area of her majesty Event. So the book is:
Enterprise Integration Patterns. Gregor Hohpe and Bobby Woolf. Best concepts book on subject. Things
like MOM, middleware, queue engines, JMS, MDBs in Java, etc. are all about this not simple topic. All conceptualized wisdom
in one place. So good that many companies were trying
to implement some product, and where beaten, after Apache Camel poped up. It just implemented all the patterns from the book, named
them as in book and became number one product for many developers in the integration area.
Listed 4 books are great ones and are quite famous.
Another 2 guys I want to mention, are unfairly forgotten I think.
Ted Neward. He has written an excellent conceptual book, mainly about Java:
Effective Enterprise Java. Besides solid background of enterprise, he writes a books in a shortcuts collection style, putting so many great references to other books and resources. The style is very good and motivational. After first pages
you will want to close his book and run get those ones that he mentions. I found many new interesting ideas for me, e.g. rule engines. He also has a nice blog, especially older posts. Unfortunately does not update it often
Real World Java EE Patterns Rethinking Best Practices.
Another great guy. Adam Bien. Not that famous, but writes good architecture books. Is actively writing nowadays. Recently
issued a new book. Highly recommended.
So we have covered most of enterprise.
Friday, 23 March 2012
Saturday, 17 March 2012
Surprisingly, but most professions are quite different from IT. Doctors, Lawyers, other normal people study a bit, maybe some years in university and voila, they are working with gained knowledge whole their life. However, in IT the things are different. You need to seriously learn some technology every other 2 years, not even being able to master it enough, start learning a new technology from scratch. And you cannot tell me that many things are common. That is just partially true, because libraries, syntax, which is majour part of productivity, always changes. E.g. Servlets or XSLT. You learn it hard, it is substantial amount of knowledge, and how often are you really applying these skill in your everyday programming life? Not often. The same as the other 50 technologies, dusting in you mental stack, and gradually getting forgotten. Luckily there are always more powerful skills than the other. Those that not simply do stuff, but accelerate doing it. Some of them can serve you all your programming life. Things of another magnitude, your productivity boosters. This is Unix. Ironically, it appeared at the beginning of programming era, and till now nothing can beat it, making it ultimate value/time investment. It is unbelievable to work with tools, written 30 years ago and be certain that once you learn it, you will be daily using them easily another 30 years. Because as it is written in wonderful "The Art Of Unix Programming" book, in my free interpretation: whoever does not grasp unix, is doomed to reinvent it, or fail miserably. Take a look at operation systems. The early branch of Windows 95-98 failed, being replaced by Windows NT and 2000 which grasped many concepts from Unix. Same for Mac OS. Now it is Unix inside in fact. But we are talking now rather about benefits of Unix techniques. The immense power lies in a couple of concepts, like keyboard beats mouse, text is our everything, small tools are piped together, immense power of regular expressions and many others wisdoms. There are just average programmers, and the top ones, those who can manipulate things thousands of times more productively. Looking at them from side it resembles a magic. Techniques I would recommend to start learning from: regexps, sed, awk, bash, vim, small unix tools. And the power will grow on you, guys.