The book starts with a short summary of all Sun Certification exams with a more detailed explanation of the Sun Certified Programmer Exam. Besides those reviews, first chapter shows how to study for the exam in an efficient way.

Review of Garmin Zumo 550 Motorcycle GPS Navigator

The rest of the book is filed with information essential for passing the exam. More over, the content is very useful in a day to day Java and its library knowledge. For example, I don’t know how about you but I didn’t have a clue that there is an Arrays class with quite a few methods helping with array types.

The text itself is well structured, information the reader should read more carefully is shown in boxes called Exam Watch. There are also similar paragraphs/boxes with text not related to the exam (called on the job).

Furthermore, every chapter ends with a summary of the study material, followed by a 2 minute drill which is a big help when you gave the exam in few hours and want to recall the material quickly. Finally, every chapter has a 10 to 20 exam questions with detailed answers. This test has similar difficulty level as the real one so you can test yourself with real life exam questions regarding the chapter that was just read. And if you thought that its enough, you get a CD with two mock exams (lasting 2 hours, the test software gives a feel of the exam structure) to test your skills even more.

What about the writing style of authors ? It’s superb! When there is a difficult subject Kathy and Bert insert a hilarious text and everything starts to look brighter Even without the witty jokes, Java language specifics are very clearly explained.

Suming it all up, this book is (in my opinion of course) a must have for every serious Java programmer even if one doesn’t wan’t to take the SCJP exam, it deciphers some Java inner workings. And as for the exam, by studying from the previous book for the 1.4 exam I managed to get a high score (only 2 missed answers), so I think it’s a good recommendation

Rating 9/10

Buy (or just look at amazon comments) SCJP Sun Certified Programmer for Java 5 Study Guide (Exam 310-055) (Certification Press Study Guides)

Usually most computer programming related books contain a language course or an API specification/description, sometimes algorithms. As a result computer industry lacks books dealing with software development in general, telling how to “do it” not in a specific language, but in a broader aspect. “The Pragmatic Programmer” is different, gives a more general view on the subject of programming, as such it is much more valuable than any book talking about specifics of a language or operating system internals.

First part of the book presents the main philosophy behind the pragmatic programmer, like taking care of a program, don’t let it deteriorate, being the catalyst of changes, looking at the big picture (not only at the details). More over a pragmatic programmer should communicate with users on their requirements, make quality one of its requirements. There is a very good section about knowledge and how to increase it, by buying diverse books regularly, , reading them with a critical eye, and even where you can learn (e.g. a bus stop, waiting in a queue to the doctor). There is also emphasis on communication, like knowing your listeners, creating appropriate documents, or even how your email should look like.

Following chapter introduces the DRY (Don’t Repeat Yourself) principle, and presents why usually the code looks like copy-pasted, and connected with it orthogonality (keep unrelated objects loose). There is also a very enlightening section about tracer bullets and building prototypes, this way the user can see earlier what is being done, and programmer can see how complicated a certain problem really is. And near the end we have a discussion about domain languages (this was a very entertaining topic for me) and estimations.Third chapter talks about programming tools, here we have a subsection about shells, giving the most out of your editor/IDE, and source code control (believe it or not, there are still workplaces that don’t use any kind of version control). In this chapter we have very helpful paragraph about talking to a duck, when you have an “unsolvable” problem, go and try to tell about it to a bubble duck, or other plastic pet, you will see how everything starts to clear out when you start to verbalize your problem.

Next chapter presents design by contract, and does it in such a good way that I started to learn Eiffel (the original design by contract language). Rest of the chapter deals with various error handling and prevention like sopping the program if it goes wrong, programming using assertions and exceptions, resource allocation balance.

Fifth chapter gives a presentation of elastic programming, how to help your program adapt to new situations. First we have a law of Demeter (keeping the minimal amount of bindings), than there is a section about meta programming, that is making the code highly configurable (e.g. allowing to change the algorithm, by changing a config file entry) keeping the generals in the code and specifics in the meta data. This last section is very interesting and I highly recommend studying it. In the same chapter authors introduce separating logic from the view and introduce Model View Controller pattern. As a last section of this chapter we have a short introduction to shared array systems (like JavaSpaces or T Spaces).

Chapter six starts with a critique of random programming, and how to program more reasonably. Following there is a section about estimation of algorithms, refactoring, unit testing (you might want to check out Test Driven Development book review for an interesting technique based on unit testing).

Next chapter deals with the “things” that you have to do before starting coding, like requirements gathering and how not to fall in the specification trap, at the end, there is a discussion of pitfalls in formal processes and methodologies.

Last chapter takes on the subject of team projects, how to bring together pragmatism and teamwork, very crucial in teams is automatization of repetitive tasks, like installing plugins to IDE or adding a header comment to all source files.

Besides the pure content, book is filled with exercises and homeworks, which increase understanding of the problem in the section, in the appendix there is a list of books and magazines that programmers should look into.

“The Pragmatic Programmer” is one of the two books on the market that take programming from this general perspective, the second one is “Code Complete” (book review), but both books do it in different way. The former gives a small article like sections with a more flexible content (and lesser number of pages), and the latter is more formal (with almost overwhelming 900 big pages). Both take a distinct way and discuss somehow different subjects, and you should read them in any order. I highly recommend “The Pragmatic Programmer” to be on the bookshelf of every programmer.

Rating: 9 out of 10

Buy now The Pragmatic Programmer: From Journeyman to Master

Introductory chapters present how software should be constructed, how important is to have upstream prerequisites.

GPS Navigator for everyone – Garmin nuvi 360 review

Moreover there are tables that help you choose how should all your software development phases look like (e.g. no code inspections or formal code inspections) based on a kind of software that is being created. The reader is guided along problem definition, requirements and architecture prerequisites.

After that, there are the main construction processed presented : detailed design and coding. There are chapters about good class designs, routine (function or procedure) construction. One of the most interesting chapters is the one about Pseudocode Programming Process, a very good read, and makes you wonder why haven’t I tried that before.

Chapters that follow give a more detailed view of coding, how to write control statements and loops. There is also a chapter about table driven routines, I must say that’s the first time I read about them.

After the coding parts, the book presents processes that are near the coding phase like quality assurance and how it can reduce the cost of project (and even the development time!). Following is a discussion of Inspections and pair programming or as the author calls them Collaborative Development. This chapter gives ans answer why to inspect/pair program the code. Next are chapters about testing tips, how to debug and refactor code. Code tuning strategies and techniques are also presented. Further more McConnel discusses how to manage construction and integration, followed by the selection of good programming tools.

The last part is about craftsmanship, how to increase your programming abilities, like developing self-commenting code.

Almost every chapter in the book ends with a checklist that should help to include the material presented to the readers programming toolbox. Chapters contain some amount of hard data from the industry statistics, to help you understand how important a certain topic is. Also a big plus goes to McConnel for “key points” at the and of each chapter, it really helps to review the material that was read.

Overall, the book is a must buy for every programmer who thinks seriously about his job. Surely it’s quite a big read, but knowledge that can be obtained from this book is almost overwhelming. I recommend also to check “The Pragmatic Programmer” as it complements “Code Complete”. You might also check out Test Driven Development for other interesting design subjects.

Rating: 8 out of 10

Buy now the Code Complete, Second Edition

Horizon T73 Treadmill review – move your muscles and start jogging in-house

The next part, shows how to develop a testing framework (xUnit) by testing it first with a previous version of the same testing framework. It is an interesting approach, but somehow, it was not as interesting as the first example, maybe it was to abstract for me. This time the examples are written in Python.

And now for the real interesting part – the last part. This one consists test-driven patterns, such as red/green bar patterns, implementing design patterns etc. If you are not new to this kind of development, this part will be the most beneficial to you.

“Test-Driven Development” is well written, with a lot of humor, if you read any book by Kent Beck than you probably know this writing style. Each steps in the examples is thoroughly explained and really should make you think about giving this kind of development a try in the next project. Moreover if you know something or even develop your software this way, then the third part will show you how you could improve your techniques. The only drawback of the book is its length, it is too short. My recommendation is: buy it!.

Rating: 7 out of 10

Buy Test Driven Development: By Example (Addison-Wesley Signature Series)