Computers Books

For those of you who haven't heard of Groovy, Groovy is a scripting language that is built on top of Java. Since it is written on top of Java, a Java developer can pick up pick Groovy in a snap.

I first heard about Groovy In Action (also known as GINA) during a Groovy presentation almost a year ago, the presenter was referring to Groovy In Action as one of the best references out at the time, After reading GINA, I was not disappointed. The roadmap given at the beginning of the book is a great guide to see how the book is organized out. As an added bonus, the book includes some great reference information at the end of the book. It contains Groovy Language information, a GDK API quick reference, and several great cheat sheets for items such as closures, lists, etc.

The book is full of great examples that you can use (some of the examples illustrate some of the finer points of the language).

In fact someone recently asked about where to find a complete specification of the Groovy Language. Guillaume Laforge, Groovy Program Manager and co-author of Groovy In Action, responded that the most current information can be found in Groovy In Action (source user@groovy.codehaus.org mailing list 3/16/2008).

Groovy in Action is one of the Groovy books that is a must have for anyone looking to get into Groovy Development.

This book is totally awesome. The book makes it very easy to jump around and come back to previous chapters. The book's online forum is great too. The author(s) respond very quickly. It is well worth the money. Order it now and you will be programming in Groovy very quickly.

Learn a new language every year - as someone once said.
I happened across Groovy a couple of months ago and was looking for some printed resource - navigating a website just isn't the same as holding a book in ones hands.
And, yes, this is a book well written and easy to read, providing all you need to gain a good understanding of the Groovy language and libraries. If you are looking for a good way to get aquainted with an excellent complement to the Java platform, go and get this book.

While getting a little long in the tooth (GINA was released pre-Groovy 1.0, Groovy is now above 1.5), the material presented in the book is still very relevant and helpful. The biggest issue is that some of the newer (and cooler!) features, such as ExpandoMetaClass, of the language are not covered.

That being said, this is still a great introduction to the a language that will likely become an important player in Java shops as developers migrate existing designs to take advantage of the power the dynamic programming provides. The authors do a great job of explaining the concepts and syntax of the language, making it easy to quickly begin writing code of your own.

While books such as Groovy Recipes: Greasing the Wheels of Java are now available that cover the newest features in Groovy, a perusal of GINA can help to flatten the learning curve.

This book is fantastic. Very well done, easy read. It was the first tech book that I read cover-to-cover -without getting bored- in a long time. The author does a good job of explaining how Groovy works under the covers and does a great job of detailing how to make effective use of it.

The language itself is also impressive and I hope Groovy gets the attention it deserves. I hope all Java developers read this to see what they're missing in Java-land. :-)

Hindsight is 20/20, I'm sure the authors are sorry they included the last chapter on Grails as they did. But I don't fault them, as I'm sure the publisher was not uninvolved in that decision... ;-)

I'm giving it 5 stars anyway. Good work!

This is a great book for seasoned IT professionals that want to learn how to secure small and medium sized networks.

As others have said, if you want to read only one book, this is the one. The authors did a great job of describing concepts and relevant low level details and tools.

I enjoyed reading most of it, but I skimmed parts that described processes that seasoned engineers have applied countless times.

Highly recommended!

Very, very good.
All the most important subjects of perimeter security, remote access, resources separation are addressed.
TCP protocol details are clearly part of the explanation, therefore the more you know of it the better it is.
Useful links and vendor specific technology references are also included, like Microsoft, Cisco and so on.
Excellent.

Stephen Northcutt has done a great job! this is the most comphrensive book on the subject. I particularly found the part on access lists very helpful. Niloufer Tamboly, CISSP

Stephen Northcutt, and the various contributing authors, have created a masterful and well rounded guide of the various considerations that go into securing the network perimeter. As a student of Information Technology this book has been instrumental in my education and has earned a permanent place on my bookshelf (when it is not in my hands directly).

Fairly decent overview of perimeter security. If your a security professional you may learn a thing or two, if your a network administrator and your idea of security is a firewall then this book is meant for you. Its a fairly easy read, but some of the examples of the commands to enter in configuring routers and hosts could be eliminated. I felt the author was just taking up space with these examples. (not a big deal but I'm taking a star away on principal) I also felt the author could have gone into a little be more detail in the VPN chapter, especially when dealing with encryption, PKI, and authenication which I felt was glossed over. (again not a big deal, but when you call yourself the definitive guide, be more definitive and save the 'commands' for the user guides")

This book is great. It teaches jQuery very effectively and in a manner that all people can understand. I highly recommend it to anyone needing/wanting to learn jQuery.

very complete overview of the topic with well layed out examples. The reference book is a better long term value.

Learning jQuery: Better Interaction Design and Web Development with Simple JavaScript Techniques is a wonderful introduction to JQuery framework. The book offers many informative code samples and extremely helpful tutorials about how to make JQuery work for you and how to deal with common issues as well as not so common issues such as; acquiring information with the use of AJAX and manipulating tubular data. From the first page it is easy to see that this book is unlike any other.

This book will aid in taking away some of that fretfully complicated mess and help the reader get a sound start with JavaScript code, serving to reveal techniques that will make the reader's code much richer as well as much more efficient.

Unlike many in of it's like this book is designed more for the jQuery beginner. All that the reader need be equipped with is a general knowledge of HTML, CSS, and a firm understanding of the syntax of JavaScript, absolutely no jQuery or framework experience is needed to understand what is being expressed in the book, or to benefit from the information that is brought to light within its pages. That said I must also stress that the book can still be immensely enlightening to those with a great deal more experience with jQuery, it can teach is old pros new and more efficient techniques.

The information provided in this particular book is concise, clear, and essentially easy to understand. Important information is highlighted to ensure that it grabs the reader's attention and the same strategy is used with helpful tips. The code sample throughout the chapters are formatted well and broken down for easier reading, there are also addition sections of code bolstered. Perhaps one of the most useful as well as unique aspects of learning jQuery is the live examples provided on web sites.

I have found that these examples give the reader a better understanding for what the codes really do. The example alone are worth the books weight in gold, they are very high quality and can be applied to various real situations. The examples are also accompanied with screenshots that enrich the information.

I call this the second javascript book that you will ever need because you will first need some background and understanding in javascript such as from: Simply JavaScript. However, once you begin working with Javascript you'll find yourself wishing for an easier way to accomplish numerous tedious tasks. The solution is jQuery an open source javascript library that is supported by a sharp team of developers. Jquery uses an OOPS approach to many common tasks and provides a framework to accomplish in 1 or 2 lines of code what would take dozens using javascript alone.

Although Jquery is pretty straightforward the online forums and documentation aren't always clear and directions for someone starting out in Jquery aren't the best. That is why I bought this book and it has been an incredible help to me by giving me a structured, ordered and organized explanation of what Jquery can do. You'll find yourself savings plenty of time with it and expand your javascript capabilities exponentially.

I love JQuery. This book is a good reference and will give you insight. I think they could have done a better job in picking the examples but what they provide is solid.

There are some excellent tutorials linked on the JQuery home site that give a better intro than the book, but having read those first the book brings some more distintions and is worthwhile.

If I could get someone to write down everything I don't know about LotusScript and Java, it would fill a book. Well, this is that book.

Hatter and Banks aren't wordy and target this book strictly at the experienced developer looking for a reference work. That makes this incredibly useful. These days I carry this book (thankfully light despite being 700 pages) between sites all the time. The lovely posters from Lotus might list all the properties and methods, but these guys provide the details underneath it.

The remarks on each class are pertinent, yet brief (as for NotesRichTextItem, "you must call the save method of the parent Notes document to save the data to disk") They include examples not only for classes, but also occasionally for methods and properties.

Interestingly, a quick check of the index for 'Index, databases' found only a reference to the updateFTIndex method for Java Database class and not to the LotusScript NotesDatabase class, while 'Registering Users' listed the LotusScript page and not the Java one. Perhaps the editors need to work on that. Fortunately, they provide a lot of cross-references on the pages, giving you page numbers for the classes mentioned in the text, reducing the need to refer to the table of contents or the index.

The print's small, but they use fonts, abbreviations and familiar symbols to get the message across clearly.

On balance, it's well worth the (money) I paid Amazon for it - it probably saved me an hour today and none of our hours come cheap, do they?

I bought this book originally expecting a full reference to Lotus and at first was a little dissappointed that it only covered LotusScript and Java. After reading it, now it is the only reference I use for LotusScript. I too have several other books, but none give the information and detaill in an easy to read format like this book. Anything you want to know about Classes, Methods, Properties, Events, and new R5 LotusScript features are covered in this book in detail with good examples. I also like how each class has it's own contents page giving page numbers for all of the assosiated Properties, Methods, and Events for QUICK reference.

This book has minimized my LotusScript related headaches! It is a one-stop resource for methods and properties for the predefined LotusScript Classes. It is hard to believe, but ()it takes me less time to write scripts, which gives me more time to enjoy the finer things in life. I would highly recommend this book to anyone, beginner or advanced.

The authors did a great job providing examples of how the properties and methods are used. I haven't written any Java yet, but when I do this book will be right by my side!

If you are new to LotusScript do not buy this book. This is a reference book for LotusScript and Java classes and a very good one at that. The developer help files can be confusing at times and it always helps to have a reference book near you.

If you are an intermediate or experienced Notes developer this is a terrific book, I have it by my desk all the time.

If you want a book to teach you LotusScript but Practical LotusScript it's great!

Exactly what I've been looking for: A no nonsense reference manual for the LotusScript and Java class libraries. Probably the most useful book a professional Notes/Domino developer can have.

This book is clear, concise, interesting (almost like an unputdownable novel by Sidney Sheldon). I'm not joking. You can read it in one or two days, do the transcenders, print out your transcender results. Before the exam review the transcenders and walk out with a 900 like me. I must mention i have six months admin and six months support experience. Just to let you know the experience level. Good luck to all.

This book is clear, concise, interesting (almost like an unputdownable novel by Sidney Sheldon). I'm not joking. You can read it in one or two days, do the transcenders, print out your transcender results. Before the exam review the transcenders and walk out with a 900 like me. I must mention i have six months admin and six months support experience. Just to let you know the experience level. Good luck to all.

Exam 70-073 is now the 1 exam most people take in order to become MCP and this book will make a big difference in the attempt. This book covers each exam objective and gives the detailed information you need in order to pass the exam on the first try.

The book of over 600 pages gives you exam tips, study tips, hands-on exercise, case studies summaries and review questions, exam questions and practice tests all to help you obtain your certification ....................

The book sis loaded with diagrams, pictures, tables and figures to make the learning process easier. The author takes out the mystery behind the NT Workstation and uncomplicates the technical jargon thus enabling to retain more information, and remember information is the key to passing the exam.

The book includes Top Score Software exam simulation; this allows you to try the exam before you go live. Overall the book is one for the technical library even after passing the exam.

As good as it gets - do not look farther....

I have looked at few of the books on this subject - this one is make you understand the subject in plain English - you do not feel stupid reading it.

Combine with a good exam test questionary - and you will make it...

I have right know - 5 books on this subject and I just passed the test on the first try with a 866 when only a 700 is required. I believe this book is what put me over the top and gave me some error room to boot! It is very easy to read and reminded me a lot of a textbook but thats a good thing, those "other" books try to make things much harder than they have to be. This book lays it out in a GREAT format. I found no errors unlike many other books and I recommend this with 5 star! - something I rarely ever give out. Good job to the author, keep it up! Highly recommend!

If you want to understand and write professional Windows Service programs, buy this book. You will find good C++ examples and best practices in Windows Service writing.

There has been so much written on the reviews for this book that I don't think I want to repeat all the good stuff said about it. The author has presented the various topics clearly and I like the style of writing. This book has been a great help. If you need to understand NT Services and how to program something decent; this is the book. Not for someone new to Windows programming. Just hope he comes out with another book soon.

The book is comprehensive, clear, and easy to read. The source code works and it is easy to follow (the code is available on-line.) The discussion on ATL COM servers is truly enlightening and by itself worth the price of the book. If you are writing an ATL COM server this book is a must, especially if it will be a multi-threaded server.

From the beginning the author has the attitude that NT services are easy to understand and his "prophecy" becomes self-fulfilling throughout the book. The book is well organized and it pays special attention to service design and usage patterns.

Also notice that the book does not cover hardware drivers. By the way, do read the previous review titled "One of a kind" as it gives very useful tips on installing ATL services (using "myservice.exe -Service") and housing COM objects in a service; I have not found that information in the book.

This book addresses all the issues related to such complex problems as NT Services. The author explains them in very great details, and makes you understand how all this works. The sample code works and you can use the classes from the book to start coding NT Services very fast. The author is very talented in explaining difficult concepts. Funny enough, this book has the best explanation on MSMQ, as well as apartments. As an alternative to the classes provided in this book, I recommend the CodeGuru NT Service C++ wizard written by Joerg Koenig. But even with a wizard, it is good to know how all this works.

No other source compares to the quality and convenience of Professional NT Services, either in book form or on the Internet. The only other way to get this information is to read sample code on MSDN, which is a less-than-optimal way to learn the subject.

Professional NT Services describes the issues involved in writing services, such as security and threading, and provides sample code every step of the way. The book also details how to build a service with ATL and even tells you how to improve ATL's implementation. It even talks a bit about Microsoft Transaction Server (now part of COM+).

Here are three bits of information that I discovered elsewhere that I wish were more evident in the book -

1. If you create an ATL service, the default registation code registers the EXE as a COM server instead of a service -- run "myservice.exe -Service" to register the service.

2. The easiest way for multiple clients to be able to use a single COM instance that's housed in the service is to implement the COM class using DECLARE_CLASSFACTORY_SINGLETON. This is your typical "server" pattern.

3. Clients that want to connect to COM objects housed in the ervice should use CLSCTX_SERVER in CoCreateInstance

Perhaps this information is buried in the book somewhere, but I didn't find it. At any rate, without this book, I wouldn't have known where to start.

Finally, for all its great qualities, the book needs to be revised for Windows 2000. It mentions some new features of "NT5" but I wonder how accurate this information really is.

One of the best programing language books I have read. If only the programing guides for other languages could be this clear and concise.

Good examples, suggestions, and notes. Is a must have for any one looking to program in Lua.

Naming this language after the moon is ironically apropos, as many of its lunatic creator's cognitive processes seem to randomly scramble themselves according to the phase of said moon. I'm no language designer myself, but if I were trying to come up with a high-level scripting language that would appeal directly to C programmers, the last thing I'd want to do is start array indices at 1 rather than 0. Sure, you have the option of altering this behavior in the constructor, but in the author's own words:

"I do not recommend the use of arrays starting at 0 in Lua. Most built-in functions assume that arrays start at index 1, and therefore they will not handle such arrays correctly."

Talk about giving you just enough rope to hang yourself. But it gets even better. Array elements in Lua are to be removed by assigning their indices the value of nil. This is all well and good, but, again in the author's own words:

"Lua uses [the nil] value as a sentinel to find the end of the array. When the array has holes--nil elements inside it--the length operator may assume any of these nil elements as the end marker. Of course, this unpredictability is hardly what you want."

No shoot, Sherlock. So why not get rid of that unpredictability? As I read further I came to the conclusion that this decision was made because doing otherwise would spoil the running theme of the language. Another favorite passage comes from page 32 when discussing the numeric for loop:

"you should never change the value of the control variable: the effect of such changes is unpredictable."

Great! I love unpredictable results. They make so much more sense than raising a predictable exception or pointing out a predictable old syntax error. Let's see now... How else can we anger C programmers? How about if we make it so "a break or return statement can appear only as the last statement of a block"? Wonderful! Now let's get rid of one of the primary attractions of high-level scripting languages--regular expressions--and say we can't include them due to size concerns (we really need to be able to brag about our entire distribution fitting on a single floppy disk, and the PCRE library is just HUGE).

These things are marginally less obnoxious than Python's significant whitespace, but still obnoxious, and apart from the multiple return values thing, I really didn't find any compelling reason to join the Lua fanboy camp in this volume. Maybe if I were a Warcraft player I'd feel differently.

As for the book itself, the writing is terse and very obviously coming from a non-native speaker. The typesetting is atrocious (good typography is one of those things you never really appreciate until it's gone) and the entire thing looks like it was printed on an old laser printer that was low on toner at Kinko's. If it were cheaper, I wouldn't care, but it's not, so I do.

Stick to the free PDF if you really have to learn Lua for something. The changes in 5.1 are not significant enough to warrant a second edition, and the flimsy, smudged paper is really not worth paying for.

Buying this book does more than support the Lua project. Having the book available will change your opinion of integrating script with C code! "Progamming in Lua" is a well-written text that makes using Lua practical. All of the best features of Lua are covered; the sample code is concise, clear and complete.

Lua is very different from C, and so allows a programmer to easily do things that are difficult in C. That makes it a perfect companion language. The only obstacle is training a C programmer to use it! That's where the book becomes useful. It's a quick read and covers all the essentials.

Even better, Lua is so well-connected to C that it is easy to switch back and forth in the course of a typical programming day, writing performance code in C and high-level logic in Lua. It is even possible to easily interact with Lua data structures in C without writing Lua code for situations where the data structures are desirable but Lua code isn't required. If you're looking for a scripting language for your next project, you need to know about Lua, and this book is the quickest way to make an informed decision.

The Lua programming language is among those gems appearing once per decade. It has a simplicity and rigor which may make other well-thought languages (such as Prolog or Scheme) pale a little.

Simple without being simplistic, Lua takes you to a new level of productivity. This is *true* productivity flowing from the essence of a well-designed language, miles away from the well-known plethora of wizards and libraries that take you months to master in order to become "productive".

With Lua you do not learn a language, you simply learn a direct, simple and natural way of doing things. Lua "clears your mind", just like Prolog does - but in a different way (see "The Art of Prolog" by Sterling & Shapiro). Few programming languages boast such quintessential brilliance.

The author of this language is truly a genius of language design and most likely the years to come will prove it. I would not be surprised that after a decade or two Mr. Ierusalimschy will be cited among folks like Sussman or Colmerauer.

How "Programming in Lua" is written shows off that it was produced by the same mind which conceived Lua itself.

Good, well organized, concise without being too dry, showing good explanations without being too verbose, this book makes you not only learn while reading, but also to envision solutions to your programming tasks while learning.

One last thing: I did *not* read exactly this book. I've read only the first half of edition 1 online, but it is enough to understand what Lua is all about.

Needless to say that I ordered a copy of the second edition - surely equal in quality.

"Trust used to be all about a handshake - and nothing has changed..."

So begins Appendix F in Vacca's book. The entirety of the book defines that critical handshake, which has been made so much more complex by Internet
freedom and opportunities. Layers of certification and handshaking, both online and offline, hashing, third parties, CA's.

Vacca includes costings, comparatives, definitions, implementation instructions, and white papers written by others with expertise in the area.

This book is a 'must read' for those of us working in IT security.

As usual, John writes a very timely book on contemporary IT issues. Most people are still afraid to use their credit cards on the net and businesses have huge constraints in terms of what can and can't be done through the web. As the rules of the game toughen for the every-ready hacking minds, government are also cracking down on such culprits, however, for the average user of electronic commercial transactions, there needs to be a stronger feeling that their money is safe. John's PKI book helps to educate those with this understandable concern, that it may now be getting safer to do business on the net.

This book covers the entire spectrum of PKI technology with an emphasis on the pratical aspects of design,implementation and use. As an IT security professional, I have found this book to be extremely useful in my job as we must constantly be on guard and make use of the latest technology to stay one step ahead of the multitude of security threats we face on a day-to-day basis.

To successfully transact business on the worldwide web, a secure network is essential. John Vacca's book explores public key infrastructures (PKIs)as a technology to provide that security. This book would be a good resource for anyone responsible for maintaining network security in big business or small.

"Trust used to be all about a handshake - and nothing has changed..."

So begins Appendix F in Vacca's book. The entirety of the book defines that critical handshake, which has been made so much more complex by Internet freedom and opportunities. Layers of certification and handshaking, both online and offline, hashing, third parties, CA's.

Vacca includes costings, comparatives, definitions, implementation instructions, and white papers written by others with expertise in the area.

Previously a developer and implementor, and now a user, I wish that we had had this information then when we were implementing PGP, and I can only hope that my host sites now are compliant.

This book is an excellent read start to finish. Topics are introduced gradually, the same topics are dug dipper as we proceed. The author makes sure you understand clearly as we proceed.
No confusions created with too many scribblings and notes, going back and forth; like in the "Head First..." I had to drop that one at end of 2 chapters, you can refer to that for some examples if at all.
With this book I never had to refer to anything at all. I definitely recommend this book over the "Head First..."

What I was most impressed in this book was how clearly it's written and yet it goes deeply on those details that can always get you confused on a certification exam.

I am very satisfied.

This is a good book to learn the concepts of EJB but for the exam you need the HFEJB book.
The details of Context objects (which method of Context object you can use in which method call of the Bean class) are more descriptive in HFEJB
If you are planning to sit for the exam this book should be accompanied by HFEJB

This is a very good book on a complex subject. Explanations of the concepts are easy to understand. Exam objectives are covered in detail with example codes and review questions.
Each chapter covers the individual exam objectives as well as summarizing the gist. Logical organization of the chapters helps conceptualize even the toughest topics.

The Quick Prep Appendix for last-minute cramming and free downloadable Whizlabs SCBCD exam simulator are very effective tools for the exam.

I recommend this book as must have SCBCD exam preparation book that can be also used as a reference book on EJB.

I used this book as a primary preparation tool for the Sun Certified Business Component Developer (SCBCD) exam. Being a beginner in EJB, I found this book to be very friendly. I liked the layout of the book in general and the writing style of the author in particular. Only relevant pieces of code are presented to focus explanation of topic in question. A complete running application may be downloaded from the author's website. The multiple choice questions at the end of every chapter and ALERTs in every chapter made remembering main points easier. Deployment descriptor elements are clarified in considerable detail and they are explained well. Please note that there are errors in this book - some of them are fairly obvious such as using a capital letter as opposed to a small letter (Java versus java) while others are not so obvious but noticeable by experienced java developers. Regardless of its minor faults, I consider this book to be a valuable addition to my library. Normally I would have a cut a star for the errors but because of its content quality, I felt compelled to give 5 stars. I just passed the exam today thanks to this book. I know that I will not hesitate to buy another book from this author. Thanks Mr.Sanghera! I recommend this book highly without any reservations whatsoever.

I have just recently started looking at smalltalk and like many people (being used to c++), when starting out in smalltalk, just going through the code didn't actually tell me much about anything, it's hard to find where anything is actually being done. After reading this book this task was significantly easier, the reason is simple, after going through this book one gets a much deeper understanding about why the code is split the way it is and gains a real insight into why this is a better approach than the usual C++ style with 100-200 lines of code methods. Kent Beck's writting makes the book a very nice read, must admit i was actually sorry when i finished it.

I wish more Java/C#/C++ programmers would read this (and maybe even learn Smalltalk) so that they can appreciate the weaknesses in those languages and possibly in their practices that they might not even realize today. I certainly did. While Robert Martin and others have offered up some of the canon of good design for contemporary developers, this little gem really reveals the "feel" of good OO.

I'm always looking for ways to make coding work better, at any level from nanosecond arithmetic operations to decade-long enterprise operations. I didn't find much of use here, but there were a few good points here (very few). Let me start with those.

The "Execute Around Method" pattern is good idea, applicable far beyond this Smalltalk context. The Beta language has "inner" inheritance, which makes the idea easy, but most other languages lack a good mechanism for undefined logic between matched operation pairs (open/close, setup/cleanup, etc.) "Enumeration" is another good one, enshrined as "Visitor" in the Gang of Four book.

Most of what's left is either trivial or Smalltalk-specific and face it, Smalltalk is mostly a cult language with nearly no commercial significance. The Smalltalk pretty-printing and variable-naming rules, fatuous at best, are just not applicable to most langages. Some of Beck's "practices" are language features (like 'super'). Other "practices", like the long chapter on Collections, seem to describe standard library classes and messages. Yet others (e.g. Type Suggesting Parameter Name) correct language defects - Smalltalk chose to give up the error detection capability offered by variable typing. Beck tries to sneak it back in with variable naming conventions sort of like Microsoft's old Hungarian naming. Some of his suggestions are just dangerous, like that one that says a constructor should "half-way construct an object in one place, then pass it off to another to finish construction. (p.23)" This distributes an object's setup responsibility across its client classes, leaves unusable and incomplete objects floating around, and causes subtle exposures in multithreaded systems - I'd rip out any code I saw built this way.

The good news is that no new trees died to make my copy of this book - I got it used, and it's returning to the used market. At least my conscience is clean on that account, no matter what I'm doing to the poor guy who buys this book next.

//wiredweird

I wish I had read this book when I started getting into OO programming. This is OO to the max, at maximum granularity.

Beck's style is clear and concise, the patterns are understandable even by a non-senior Smalltalker like me.

SBPP has changed me. Kent Beck has changed me.

SBPP shed a new light on my previous knowledge of "patterns" in computer programming. I was deep in the DP tar pit. SBPP saved me. SBPP changed almost all my thoughts on programming. It has changed what I value, and how I pursue it.

Kent Beck says that he is not a great programmer but just a pretty good programmer with great habits. Build great habits with this book. Read and reread this book every morn.

If you have studied DP, this book will open your eyes to the wider world of patterns. You will think about DPs quite differently after this book. You will be able to escape from the bad effects of DP abuse.

If DPs were nouns, verbs and adverbs/adjectives, SBPP are articles and auxiliary verbs. SBPP are used much more frequently than DPs. When you learn a language it is very important to learn more frequently used words first. It could be less efficient(or even dangerous) to learn "appreciate" before "thank (you)".

--JuneKim